[INFO] fetching crate mj 0.4.3...
[INFO] testing mj-0.4.3 against 1.60.0 for beta-1.61-1
[INFO] extracting crate mj 0.4.3 into /workspace/builds/worker-22/source
[INFO] validating manifest of crates.io crate mj 0.4.3 on toolchain 1.60.0
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1.60.0" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate mj 0.4.3
[INFO] finished tweaking crates.io crate mj 0.4.3
[INFO] tweaked toml for crates.io crate mj 0.4.3 written to /workspace/builds/worker-22/source/Cargo.toml
[INFO] crate crates.io crate mj 0.4.3 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+1.60.0" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded backtrace v0.3.38
[INFO] [stderr]   Downloaded termion v1.5.3
[INFO] [stderr]   Downloaded tui v0.6.2
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/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:b0c94ce3c1162fcb8e57cac5b65ec2f72eabb1eebea4fcc35e269e823f681646" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] c42ee41be4019ad1b446d9093e112118552eb446cadac169a1e11e2d2610df52
[INFO] running `Command { std: "docker" "start" "-a" "c42ee41be4019ad1b446d9093e112118552eb446cadac169a1e11e2d2610df52", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c42ee41be4019ad1b446d9093e112118552eb446cadac169a1e11e2d2610df52", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "c42ee41be4019ad1b446d9093e112118552eb446cadac169a1e11e2d2610df52", kill_on_drop: false }`
[INFO] [stdout] c42ee41be4019ad1b446d9093e112118552eb446cadac169a1e11e2d2610df52
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/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=warn" "-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:b0c94ce3c1162fcb8e57cac5b65ec2f72eabb1eebea4fcc35e269e823f681646" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 6ad1b2ff842edbaa269ef56cd02782c379d3e9223018f1310e070ba76956abfd
[INFO] running `Command { std: "docker" "start" "-a" "6ad1b2ff842edbaa269ef56cd02782c379d3e9223018f1310e070ba76956abfd", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]    Compiling autocfg v0.1.6
[INFO] [stderr]    Compiling libc v0.2.62
[INFO] [stderr]    Compiling rand_core v0.4.2
[INFO] [stderr]    Compiling proc-macro2 v1.0.5
[INFO] [stderr]    Compiling memchr v2.2.1
[INFO] [stderr]    Compiling bitflags v1.2.0
[INFO] [stderr]    Compiling unicode-xid v0.2.0
[INFO] [stderr]    Compiling serde v1.0.101
[INFO] [stderr]    Compiling log v0.4.8
[INFO] [stderr]    Compiling syn v1.0.5
[INFO] [stderr]    Compiling unicode-width v0.1.6
[INFO] [stderr]    Compiling numtoa v0.1.0
[INFO] [stderr]    Compiling either v1.5.3
[INFO] [stderr]    Compiling vec_map v0.8.1
[INFO] [stderr]    Compiling regex-syntax v0.6.12
[INFO] [stderr]    Compiling unicode-segmentation v1.3.0
[INFO] [stderr]    Compiling ansi_term v0.11.0
[INFO] [stderr]    Compiling cassowary v0.3.0
[INFO] [stderr]    Compiling thread_local v0.3.6
[INFO] [stderr]    Compiling itertools v0.8.0
[INFO] [stderr]    Compiling textwrap v0.11.0
[INFO] [stderr]    Compiling rand_core v0.3.1
[INFO] [stderr]    Compiling rand_jitter v0.1.4
[INFO] [stderr]    Compiling rand_pcg v0.1.2
[INFO] [stderr]    Compiling rand_chacha v0.1.1
[INFO] [stderr]    Compiling num-traits v0.2.8
[INFO] [stderr]    Compiling rand v0.6.5
[INFO] [stderr]    Compiling num-integer v0.1.41
[INFO] [stderr]    Compiling rand_hc v0.1.0
[INFO] [stderr]    Compiling rand_isaac v0.1.1
[INFO] [stderr]    Compiling rand_xorshift v0.1.1
[INFO] [stderr]    Compiling quote v1.0.2
[INFO] [stderr]    Compiling rand_os v0.1.3
[INFO] [stderr]    Compiling termion v1.5.3
[INFO] [stderr]    Compiling dirs-sys v0.3.4
[INFO] [stderr]    Compiling atty v0.2.13
[INFO] [stderr]    Compiling time v0.1.42
[INFO] [stderr]    Compiling aho-corasick v0.7.6
[INFO] [stderr]    Compiling clap v2.33.0
[INFO] [stderr]    Compiling dirs v2.0.2
[INFO] [stderr]    Compiling tui v0.6.2
[INFO] [stderr]    Compiling regex v1.3.1
[INFO] [stderr]    Compiling uuid v0.7.4
[INFO] [stderr]    Compiling chrono v0.4.9
[INFO] [stderr]    Compiling toml v0.5.3
[INFO] [stderr]    Compiling serde_derive v1.0.101
[INFO] [stderr]    Compiling mj v0.4.3 (/opt/rustwide/workdir)
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:207:16
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].into_iter(),
[INFO] [stdout]     |                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].iter(),
[INFO] [stdout]     |                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stdout]     |       ++++++++++++++++++++++++        ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:209:69
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:210:64
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:211:67
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                   ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:212:64
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:213:64
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:214:69
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:215:52
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stdout]     |                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:216:69
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:217:68
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:218:54
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stdout]     |                                                      ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:219:69
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:220:60
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stdout]     |                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stdout]     |                                                            ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:221:61
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stdout]     |                                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stdout]     |                                                             ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:222:68
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:223:69
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:224:47
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stdout]     |                                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stdout]     |                                               ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 17 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:207:16
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].into_iter(),
[INFO] [stdout]     |                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].iter(),
[INFO] [stdout]     |                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stdout]     |       ++++++++++++++++++++++++        ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:209:69
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:210:64
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:211:67
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                   ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:212:64
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:213:64
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:214:69
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:215:52
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stdout]     |                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:216:69
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:217:68
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:218:54
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stdout]     |                                                      ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:219:69
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:220:60
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stdout]     |                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stdout]     |                                                            ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:221:61
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stdout]     |                                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stdout]     |                                                             ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:222:68
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:223:69
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:224:47
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stdout]     |                                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stdout]     |                                               ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 17 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 18.53s
[INFO] running `Command { std: "docker" "inspect" "6ad1b2ff842edbaa269ef56cd02782c379d3e9223018f1310e070ba76956abfd", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "6ad1b2ff842edbaa269ef56cd02782c379d3e9223018f1310e070ba76956abfd", kill_on_drop: false }`
[INFO] [stdout] 6ad1b2ff842edbaa269ef56cd02782c379d3e9223018f1310e070ba76956abfd
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/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=warn" "-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:b0c94ce3c1162fcb8e57cac5b65ec2f72eabb1eebea4fcc35e269e823f681646" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] b216c6852f622d845d9acfa4f8a302a84fd14a05b4b81de76ca841a97ed69bec
[INFO] running `Command { std: "docker" "start" "-a" "b216c6852f622d845d9acfa4f8a302a84fd14a05b4b81de76ca841a97ed69bec", kill_on_drop: false }`
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:207:16
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].into_iter(),
[INFO] [stdout]     |                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].iter(),
[INFO] [stdout]     |                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stdout]     |       ++++++++++++++++++++++++        ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:209:69
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:210:64
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:211:67
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                   ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:212:64
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:213:64
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:214:69
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:215:52
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stdout]     |                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:216:69
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:217:68
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:218:54
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stdout]     |                                                      ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:219:69
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:220:60
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stdout]     |                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stdout]     |                                                            ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:221:61
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stdout]     |                                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stdout]     |                                                             ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:222:68
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:223:69
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:224:47
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stdout]     |                                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stdout]     |                                               ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling mj v0.4.3 (/opt/rustwide/workdir)
[INFO] [stdout] warning: 17 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:207:16
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].into_iter(),
[INFO] [stdout]     |                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].iter(),
[INFO] [stdout]     |                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stdout]     |       ++++++++++++++++++++++++        ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:209:69
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:210:64
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:211:67
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                   ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:212:64
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:213:64
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:214:69
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:215:52
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stdout]     |                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:216:69
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:217:68
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:218:54
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stdout]     |                                                      ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:219:69
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:220:60
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stdout]     |                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stdout]     |                                                            ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:221:61
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stdout]     |                                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stdout]     |                                                             ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:222:68
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:223:69
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:224:47
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stdout]     |                                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stdout]     |                                               ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 17 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:207:16
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].into_iter(),
[INFO] [stdout]     |                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].iter(),
[INFO] [stdout]     |                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stdout]     |       ++++++++++++++++++++++++        ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:209:69
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:210:64
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:211:67
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                   ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:212:64
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:213:64
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:214:69
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:215:52
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stdout]     |                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:216:69
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:217:68
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:218:54
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stdout]     |                                                      ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:219:69
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:220:60
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stdout]     |                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stdout]     |                                                            ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:221:61
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stdout]     |                                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stdout]     |                                                             ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:222:68
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:223:69
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:224:47
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stdout]     |                                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stdout]     |                                               ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:207:16
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].into_iter(),
[INFO] [stdout]     |                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 207 |       ["", ""].iter(),
[INFO] [stdout]     |                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stdout]     |       ++++++++++++++++++++++++        ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:209:69
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:210:64
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:211:67
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                   ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                   ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:212:64
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:213:64
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stdout]     |                                                                ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stdout]     |                                                                ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:214:69
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:215:52
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stdout]     |                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stdout]     |                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:216:69
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:217:68
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:218:54
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stdout]     |                                                      ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stdout]     |                                                      ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:219:69
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:220:60
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stdout]     |                                                            ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stdout]     |                                                            ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:221:61
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stdout]     |                                                             ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stdout]     |                                                             ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:222:68
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stdout]     |                                                                    ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stdout]     |                                                                    ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:223:69
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stdout]     |                                                                     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stdout]     |                                                                     ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stdout]    --> src/core/shell/view.rs:224:47
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stdout]     |                                               ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this changes meaning in Rust 2021
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stdout] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stdout]     |                                               ~~~~
[INFO] [stdout] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stdout]     |
[INFO] [stdout] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stdout]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 17 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 17 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished test [unoptimized + debuginfo] target(s) in 2.15s
[INFO] running `Command { std: "docker" "inspect" "b216c6852f622d845d9acfa4f8a302a84fd14a05b4b81de76ca841a97ed69bec", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b216c6852f622d845d9acfa4f8a302a84fd14a05b4b81de76ca841a97ed69bec", kill_on_drop: false }`
[INFO] [stdout] b216c6852f622d845d9acfa4f8a302a84fd14a05b4b81de76ca841a97ed69bec
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-22/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=warn" "-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:b0c94ce3c1162fcb8e57cac5b65ec2f72eabb1eebea4fcc35e269e823f681646" "/opt/rustwide/cargo-home/bin/cargo" "+1.60.0" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] aacddd0a0fe398716aae8f680db18f52bfc340c3279f8d2e01dfe63531f32163
[INFO] running `Command { std: "docker" "start" "-a" "aacddd0a0fe398716aae8f680db18f52bfc340c3279f8d2e01dfe63531f32163", kill_on_drop: false }`
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:207:16
[INFO] [stderr]     |
[INFO] [stderr] 207 |       ["", ""].into_iter(),
[INFO] [stderr]     |                ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(array_into_iter)]` on by default
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 207 |       ["", ""].iter(),
[INFO] [stderr]     |                ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 207 |       IntoIterator::into_iter(["", ""]),
[INFO] [stderr]     |       ++++++++++++++++++++++++        ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:209:69
[INFO] [stderr]     |
[INFO] [stderr] 209 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stderr]     |                                                                     ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 209 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stderr]     |                                                                     ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 209 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:210:64
[INFO] [stderr]     |
[INFO] [stderr] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].into_iter(), row_style),
[INFO] [stderr]     |                                                                ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 210 |         Row::StyledData(["  alt-i ", " Switch to [Ideas] tab"].iter(), row_style),
[INFO] [stderr]     |                                                                ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 210 |         Row::StyledData(IntoIterator::into_iter(["  alt-i ", " Switch to [Ideas] tab"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:211:67
[INFO] [stderr]     |
[INFO] [stderr] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].into_iter(), row_style),
[INFO] [stderr]     |                                                                   ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 211 |         Row::StyledData(["  alt-j ", " Switch to [Journals] tab"].iter(), row_style),
[INFO] [stderr]     |                                                                   ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 211 |         Row::StyledData(IntoIterator::into_iter(["  alt-j ", " Switch to [Journals] tab"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                         ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:212:64
[INFO] [stderr]     |
[INFO] [stderr] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].into_iter(), row_style),
[INFO] [stderr]     |                                                                ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 212 |         Row::StyledData(["  alt-n ", " Switch to [Notes] tab"].iter(), row_style),
[INFO] [stderr]     |                                                                ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 212 |         Row::StyledData(IntoIterator::into_iter(["  alt-n ", " Switch to [Notes] tab"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:213:64
[INFO] [stderr]     |
[INFO] [stderr] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].into_iter(), row_style),
[INFO] [stderr]     |                                                                ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 213 |         Row::StyledData(["  alt-t ", " Switch to [Tasks] tab"].iter(), row_style),
[INFO] [stderr]     |                                                                ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 213 |         Row::StyledData(IntoIterator::into_iter(["  alt-t ", " Switch to [Tasks] tab"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                      ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:214:69
[INFO] [stderr]     |
[INFO] [stderr] 214 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stderr]     |                                                                     ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 214 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stderr]     |                                                                     ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 214 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:215:52
[INFO] [stderr]     |
[INFO] [stderr] 215 |         Row::StyledData(["  alt-h ", " Show help"].into_iter(), row_style),
[INFO] [stderr]     |                                                    ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 215 |         Row::StyledData(["  alt-h ", " Show help"].iter(), row_style),
[INFO] [stderr]     |                                                    ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 215 |         Row::StyledData(IntoIterator::into_iter(["  alt-h ", " Show help"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                          ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:216:69
[INFO] [stderr]     |
[INFO] [stderr] 216 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stderr]     |                                                                     ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 216 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stderr]     |                                                                     ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 216 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:217:68
[INFO] [stderr]     |
[INFO] [stderr] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].into_iter(), row_style),
[INFO] [stderr]     |                                                                    ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 217 |         Row::StyledData([" ctrl-w ", " Delete last word in input"].iter(), row_style),
[INFO] [stderr]     |                                                                    ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 217 |         Row::StyledData(IntoIterator::into_iter([" ctrl-w ", " Delete last word in input"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:218:54
[INFO] [stderr]     |
[INFO] [stderr] 218 |         Row::StyledData(["    esc ", " Clear input"].into_iter(), row_style),
[INFO] [stderr]     |                                                      ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 218 |         Row::StyledData(["    esc ", " Clear input"].iter(), row_style),
[INFO] [stderr]     |                                                      ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 218 |         Row::StyledData(IntoIterator::into_iter(["    esc ", " Clear input"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                            ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:219:69
[INFO] [stderr]     |
[INFO] [stderr] 219 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stderr]     |                                                                     ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 219 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stderr]     |                                                                     ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 219 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:220:60
[INFO] [stderr]     |
[INFO] [stderr] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].into_iter(), row_style),
[INFO] [stderr]     |                                                            ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 220 |         Row::StyledData(["  enter ", " Edit/create entry"].iter(), row_style),
[INFO] [stderr]     |                                                            ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 220 |         Row::StyledData(IntoIterator::into_iter(["  enter ", " Edit/create entry"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                  ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:221:61
[INFO] [stderr]     |
[INFO] [stderr] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].into_iter(), row_style),
[INFO] [stderr]     |                                                             ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 221 |         Row::StyledData(["  alt-s ", " Rotate task status"].iter(), row_style),
[INFO] [stderr]     |                                                             ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 221 |         Row::StyledData(IntoIterator::into_iter(["  alt-s ", " Rotate task status"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                   ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:222:68
[INFO] [stderr]     |
[INFO] [stderr] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].into_iter(), row_style),
[INFO] [stderr]     |                                                                    ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 222 |         Row::StyledData([" ctrl-d ", " Delete entry under cursor"].iter(), row_style),
[INFO] [stderr]     |                                                                    ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 222 |         Row::StyledData(IntoIterator::into_iter([" ctrl-d ", " Delete entry under cursor"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                          ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:223:69
[INFO] [stderr]     |
[INFO] [stderr] 223 |         Row::StyledData(["--------", "---------------------------"].into_iter(), hr_style),
[INFO] [stderr]     |                                                                     ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 223 |         Row::StyledData(["--------", "---------------------------"].iter(), hr_style),
[INFO] [stderr]     |                                                                     ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 223 |         Row::StyledData(IntoIterator::into_iter(["--------", "---------------------------"]), hr_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                                           ~
[INFO] [stderr] 
[INFO] [stderr] warning: this method call resolves to `<&[T; N] as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to <[T; N] as IntoIterator>::into_iter in Rust 2021
[INFO] [stderr]    --> src/core/shell/view.rs:224:47
[INFO] [stderr]     |
[INFO] [stderr] 224 |         Row::StyledData([" ctrl-q ", " Quit"].into_iter(), row_style),
[INFO] [stderr]     |                                               ^^^^^^^^^
[INFO] [stderr]     |
[INFO] [stderr]     = warning: this changes meaning in Rust 2021
[INFO] [stderr]     = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/IntoIterator-for-arrays.html>
[INFO] [stderr] help: use `.iter()` instead of `.into_iter()` to avoid ambiguity
[INFO] [stderr]     |
[INFO] [stderr] 224 |         Row::StyledData([" ctrl-q ", " Quit"].iter(), row_style),
[INFO] [stderr]     |                                               ~~~~
[INFO] [stderr] help: or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
[INFO] [stderr]     |
[INFO] [stderr] 224 |         Row::StyledData(IntoIterator::into_iter([" ctrl-q ", " Quit"]), row_style),
[INFO] [stderr]     |                         ++++++++++++++++++++++++                     ~
[INFO] [stderr] 
[INFO] [stderr] warning: `mj` (lib) generated 17 warnings
[INFO] [stderr] warning: `mj` (lib test) generated 17 warnings (17 duplicates)
[INFO] [stderr] warning: `mj` (bin "mj" test) generated 17 warnings (17 duplicates)
[INFO] [stderr] warning: `mj` (bin "mj") generated 17 warnings (17 duplicates)
[INFO] [stderr]     Finished test [unoptimized + debuginfo] target(s) in 0.04s
[INFO] [stderr]      Running unittests (/opt/rustwide/target/debug/deps/mj-a5d1180ac500ec86)
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stderr]      Running unittests (/opt/rustwide/target/debug/deps/mj-2ceeb13c1a5f60f1)
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stderr]      Running tests/config.rs (/opt/rustwide/target/debug/deps/config-0bd8cb83525667f9)
[INFO] [stdout] 
[INFO] [stdout] running 3 tests
[INFO] [stdout] test serialize_config ... ok
[INFO] [stdout] test deserialize_config ... ok
[INFO] [stdout] test reserialize_config ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stderr]      Running tests/date.rs (/opt/rustwide/target/debug/deps/date-e32b3c8d9fcab2ad)
[INFO] [stdout] 
[INFO] [stdout] running 4 tests
[INFO] [stdout] test parse_date ... ok
[INFO] [stdout] test parse_today ... ok
[INFO] [stdout] test fail_to_parse_date ... ok
[INFO] [stdout] test parse_relative_date ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s
[INFO] [stdout] 
[INFO] [stderr]      Running tests/vault.rs (/opt/rustwide/target/debug/deps/vault-8199c20ee47d94b4)
[INFO] [stdout] 
[INFO] [stdout] running 1 test
[INFO] [stderr]    Doc-tests mj
[INFO] [stdout] test bootstrap_in_empty_folder ... ok
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] running 0 tests
[INFO] [stdout] 
[INFO] [stdout] test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "aacddd0a0fe398716aae8f680db18f52bfc340c3279f8d2e01dfe63531f32163", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "aacddd0a0fe398716aae8f680db18f52bfc340c3279f8d2e01dfe63531f32163", kill_on_drop: false }`
[INFO] [stdout] aacddd0a0fe398716aae8f680db18f52bfc340c3279f8d2e01dfe63531f32163