[INFO] fetching crate rulinalg 0.4.2...
[INFO] checking rulinalg-0.4.2 against try#f47dd4da3ae8c32c9e65d307bfe640b143e674df for pr-77526
[INFO] extracting crate rulinalg 0.4.2 into /workspace/builds/worker-9/source
[INFO] validating manifest of crates.io crate rulinalg 0.4.2 on toolchain f47dd4da3ae8c32c9e65d307bfe640b143e674df
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+f47dd4da3ae8c32c9e65d307bfe640b143e674df" "read-manifest" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] started tweaking crates.io crate rulinalg 0.4.2
[INFO] finished tweaking crates.io crate rulinalg 0.4.2
[INFO] tweaked toml for crates.io crate rulinalg 0.4.2 written to /workspace/builds/worker-9/source/Cargo.toml
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+f47dd4da3ae8c32c9e65d307bfe640b143e674df" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update", kill_on_drop: false }`
[INFO] running `Command { std: "/workspace/cargo-home/bin/cargo" "+f47dd4da3ae8c32c9e65d307bfe640b143e674df" "fetch" "--locked" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded quickcheck v0.4.1
[INFO] [stderr]   Downloaded csv v0.14.7
[INFO] [stderr]   Downloaded env_logger v0.3.5
[INFO] [stderr]   Downloaded itertools v0.5.10
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-9/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-9/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" "rustops/crates-build-env@sha256:d92eaeed33fa75130ca1ee6c8a01d1ffb62bac859dfdfb3450e3e5d1c0146529" "/opt/rustwide/cargo-home/bin/cargo" "+f47dd4da3ae8c32c9e65d307bfe640b143e674df" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] e400b121c0b0bd34a4c4d9fb13754881d62404fcca89ce2861cf3a0ab8cf7946
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] running `Command { std: "docker" "start" "-a" "e400b121c0b0bd34a4c4d9fb13754881d62404fcca89ce2861cf3a0ab8cf7946", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "e400b121c0b0bd34a4c4d9fb13754881d62404fcca89ce2861cf3a0ab8cf7946", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "e400b121c0b0bd34a4c4d9fb13754881d62404fcca89ce2861cf3a0ab8cf7946", kill_on_drop: false }`
[INFO] [stdout] e400b121c0b0bd34a4c4d9fb13754881d62404fcca89ce2861cf3a0ab8cf7946
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-9/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-9/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "rustops/crates-build-env@sha256:d92eaeed33fa75130ca1ee6c8a01d1ffb62bac859dfdfb3450e3e5d1c0146529" "/opt/rustwide/cargo-home/bin/cargo" "+f47dd4da3ae8c32c9e65d307bfe640b143e674df" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 4801075f2927fce8ba830f8a101baf9a574d997692be8735bd60656dcbca52a6
[INFO] [stderr] WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.
[INFO] running `Command { std: "docker" "start" "-a" "4801075f2927fce8ba830f8a101baf9a574d997692be8735bd60656dcbca52a6", kill_on_drop: false }`
[INFO] [stderr]    Compiling autocfg v1.0.1
[INFO] [stderr]    Compiling libc v0.2.79
[INFO] [stderr]    Compiling log v0.4.11
[INFO] [stderr]     Checking cfg-if v0.1.10
[INFO] [stderr]    Compiling matrixmultiply v0.1.15
[INFO] [stderr]     Checking rawpointer v0.1.0
[INFO] [stderr]     Checking either v1.6.1
[INFO] [stderr]     Checking itertools v0.5.10
[INFO] [stderr]    Compiling num-traits v0.2.12
[INFO] [stderr]    Compiling num-integer v0.1.43
[INFO] [stderr]    Compiling num-iter v0.1.41
[INFO] [stderr]     Checking log v0.3.9
[INFO] [stderr]     Checking memchr v0.1.11
[INFO] [stderr]     Checking thread-id v2.0.0
[INFO] [stderr]     Checking rand v0.4.6
[INFO] [stderr]     Checking thread_local v0.2.7
[INFO] [stderr]     Checking aho-corasick v0.5.3
[INFO] [stderr]     Checking regex v0.1.80
[INFO] [stderr]     Checking rand v0.3.23
[INFO] [stderr]     Checking num v0.1.42
[INFO] [stderr]     Checking rulinalg v0.4.2 (/opt/rustwide/workdir)
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/bidiagonal.rs:41:28
[INFO] [stdout]    |
[INFO] [stdout] 41 |                 h_holder = try!(Matrix::make_householder(&lower_slice.iter()
[INFO] [stdout]    |                            ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(deprecated)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/bidiagonal.rs:69:36
[INFO] [stdout]    |
[INFO] [stdout] 69 |                 let row_h_holder = try!(Matrix::make_householder(row).map_err(|_| {
[INFO] [stdout]    |                                    ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:124:25
[INFO] [stdout]     |
[INFO] [stdout] 124 |         let (b, u, v) = try!(self.svd_unordered());
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:129:25
[INFO] [stdout]     |
[INFO] [stdout] 129 |         let (b, u, v) = try!(self.svd_golub_reinsch());
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:149:37
[INFO] [stdout]     |
[INFO] [stdout] 149 |         let (mut b, mut u, mut v) = try!(self.bidiagonal_decomp()
[INFO] [stdout]     |                                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:214:17
[INFO] [stdout]     |
[INFO] [stdout] 214 |                 try!(Matrix::<T>::golub_kahan_svd_step(&mut b, &mut u, &mut v, p, q)
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:254:22
[INFO] [stdout]     |
[INFO] [stdout] 254 |         let c_eigs = try!(c.clone().eigenvalues());
[INFO] [stdout]     |                      ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/hessenberg.rs:47:32
[INFO] [stdout]    |
[INFO] [stdout] 47 |                 h_holder_vec = try!(Matrix::make_householder_vec(&lower_slice.iter()
[INFO] [stdout]    |                                ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/hessenberg.rs:126:32
[INFO] [stdout]     |
[INFO] [stdout] 126 |                 h_holder_vec = try!(Matrix::make_householder_vec(&lower_slice.iter()
[INFO] [stdout]     |                                ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/hessenberg.rs:141:24
[INFO] [stdout]     |
[INFO] [stdout] 141 |         Ok((transform, try!(self.upper_hessenberg())))
[INFO] [stdout]     |                        ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/lu.rs:277:23
[INFO] [stdout]     |
[INFO] [stdout] 277 |             let col = try!(self.solve(e));
[INFO] [stdout]     |                       ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/eigen.rs:85:21
[INFO] [stdout]    |
[INFO] [stdout] 85 |         let mut h = try!(self
[INFO] [stdout]    |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:107:35
[INFO] [stdout]     |
[INFO] [stdout] 107 |                 let householder = try!(Matrix::make_householder(&[x, y, z]).map_err(|_| {
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:199:27
[INFO] [stdout]     |
[INFO] [stdout] 199 |         let eigenvalues = try!(self.direct_2_by_2_eigenvalues());
[INFO] [stdout]     |                           ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:226:26
[INFO] [stdout]     |
[INFO] [stdout] 226 |         let (u, mut h) = try!(self.upper_hess_decomp().map_err(|_| {
[INFO] [stdout]     |                          ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:250:35
[INFO] [stdout]     |
[INFO] [stdout] 250 |                 let householder = try!(Matrix::make_householder(&[x, y, z]).map_err(|_| {
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:449:13
[INFO] [stdout]     |
[INFO] [stdout] 449 |             try!(write!(f, "{}", left_delimiter));
[INFO] [stdout]     |             ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:453:25
[INFO] [stdout]     |
[INFO] [stdout] 453 |                         try!(write!(f, "{:1$.2$}", datum, width, places));
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:456:25
[INFO] [stdout]     |
[INFO] [stdout] 456 |                         try!(write!(f, "{:1$}", datum, width));
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:460:21
[INFO] [stdout]     |
[INFO] [stdout] 460 |                     try!(write!(f, " "));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:469:17
[INFO] [stdout]     |
[INFO] [stdout] 469 |                 try!(write_row(f,
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:474:17
[INFO] [stdout]     |
[INFO] [stdout] 474 |                 try!(f.write_str("\n"));
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:476:21
[INFO] [stdout]     |
[INFO] [stdout] 476 |                     try!(write_row(f,
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:481:21
[INFO] [stdout]     |
[INFO] [stdout] 481 |                     try!(f.write_str("\n"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/convert.rs:89:35
[INFO] [stdout]    |
[INFO] [stdout] 89 |         Ok(Matrix::<U>::new(m, n, try!(converted_data)))
[INFO] [stdout]    |                                   ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:138:9
[INFO] [stdout]     |
[INFO] [stdout] 138 |         try!(write!(f, "["));
[INFO] [stdout]     |         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:142:21
[INFO] [stdout]     |
[INFO] [stdout] 142 |                     try!(write!(f, " {:.*}", places, datum));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:145:21
[INFO] [stdout]     |
[INFO] [stdout] 145 |                     try!(write!(f, " {}", datum));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 try!(write!(f, ","));
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]     --> src/matrix/base/mod.rs:1579:28
[INFO] [stdout]      |
[INFO] [stdout] 1579 |     fn apply(mut self, f: &Fn(T) -> T) -> Self
[INFO] [stdout]      |                            ^^^^^^^^^^ help: use `dyn`: `dyn Fn(T) -> T`
[INFO] [stdout]      |
[INFO] [stdout]      = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]   --> src/error.rs:13:16
[INFO] [stdout]    |
[INFO] [stdout] 13 |     error: Box<error::Error + Send + Sync>,
[INFO] [stdout]    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn error::Error + Send + Sync`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]   --> src/error.rs:39:27
[INFO] [stdout]    |
[INFO] [stdout] 39 |         where E: Into<Box<error::Error + Send + Sync>>
[INFO] [stdout]    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn error::Error + Send + Sync`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]    --> src/vector/impl_vec.rs:185:32
[INFO] [stdout]     |
[INFO] [stdout] 185 |     pub fn apply(mut self, f: &Fn(T) -> T) -> Vector<T> {
[INFO] [stdout]     |                                ^^^^^^^^^^ help: use `dyn`: `dyn Fn(T) -> T`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Checking env_logger v0.3.5
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]   --> src/macros/matrix_eq.rs:94:61
[INFO] [stdout]    |
[INFO] [stdout] 94 |                 formatted_mismatches = formatted_mismatches.trim_right().to_string();
[INFO] [stdout]    |                                                             ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:187:61
[INFO] [stdout]     |
[INFO] [stdout] 187 |                 formatted_mismatches = formatted_mismatches.trim_right().to_string();
[INFO] [stdout]     |                                                             ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Checking quickcheck v0.4.1
[INFO] [stdout] warning: use of deprecated associated function `std::error::Error::description`: use the Display impl or to_string()
[INFO] [stdout]   --> src/error.rs:55:20
[INFO] [stdout]    |
[INFO] [stdout] 55 |         self.error.description()
[INFO] [stdout]    |                    ^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/utils.rs:105:34
[INFO] [stdout]     |
[INFO] [stdout] 105 | pub fn in_place_vec_bin_op<F, T>(mut u: &mut [T], v: &[T], mut f: F)
[INFO] [stdout]     |                                  ----^
[INFO] [stdout]     |                                  |
[INFO] [stdout]     |                                  help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/bidiagonal.rs:41:28
[INFO] [stdout]    |
[INFO] [stdout] 41 |                 h_holder = try!(Matrix::make_householder(&lower_slice.iter()
[INFO] [stdout]    |                            ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(deprecated)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/bidiagonal.rs:69:36
[INFO] [stdout]    |
[INFO] [stdout] 69 |                 let row_h_holder = try!(Matrix::make_householder(row).map_err(|_| {
[INFO] [stdout]    |                                    ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:124:25
[INFO] [stdout]     |
[INFO] [stdout] 124 |         let (b, u, v) = try!(self.svd_unordered());
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:129:25
[INFO] [stdout]     |
[INFO] [stdout] 129 |         let (b, u, v) = try!(self.svd_golub_reinsch());
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:149:37
[INFO] [stdout]     |
[INFO] [stdout] 149 |         let (mut b, mut u, mut v) = try!(self.bidiagonal_decomp()
[INFO] [stdout]     |                                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:214:17
[INFO] [stdout]     |
[INFO] [stdout] 214 |                 try!(Matrix::<T>::golub_kahan_svd_step(&mut b, &mut u, &mut v, p, q)
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/svd.rs:254:22
[INFO] [stdout]     |
[INFO] [stdout] 254 |         let c_eigs = try!(c.clone().eigenvalues());
[INFO] [stdout]     |                      ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/hessenberg.rs:47:32
[INFO] [stdout]    |
[INFO] [stdout] 47 |                 h_holder_vec = try!(Matrix::make_householder_vec(&lower_slice.iter()
[INFO] [stdout]    |                                ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/hessenberg.rs:126:32
[INFO] [stdout]     |
[INFO] [stdout] 126 |                 h_holder_vec = try!(Matrix::make_householder_vec(&lower_slice.iter()
[INFO] [stdout]     |                                ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/hessenberg.rs:141:24
[INFO] [stdout]     |
[INFO] [stdout] 141 |         Ok((transform, try!(self.upper_hessenberg())))
[INFO] [stdout]     |                        ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/lu.rs:277:23
[INFO] [stdout]     |
[INFO] [stdout] 277 |             let col = try!(self.solve(e));
[INFO] [stdout]     |                       ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/matrix/decomposition/eigen.rs:85:21
[INFO] [stdout]    |
[INFO] [stdout] 85 |         let mut h = try!(self
[INFO] [stdout]    |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:107:35
[INFO] [stdout]     |
[INFO] [stdout] 107 |                 let householder = try!(Matrix::make_householder(&[x, y, z]).map_err(|_| {
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:199:27
[INFO] [stdout]     |
[INFO] [stdout] 199 |         let eigenvalues = try!(self.direct_2_by_2_eigenvalues());
[INFO] [stdout]     |                           ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:226:26
[INFO] [stdout]     |
[INFO] [stdout] 226 |         let (u, mut h) = try!(self.upper_hess_decomp().map_err(|_| {
[INFO] [stdout]     |                          ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/decomposition/eigen.rs:250:35
[INFO] [stdout]     |
[INFO] [stdout] 250 |                 let householder = try!(Matrix::make_householder(&[x, y, z]).map_err(|_| {
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:449:13
[INFO] [stdout]     |
[INFO] [stdout] 449 |             try!(write!(f, "{}", left_delimiter));
[INFO] [stdout]     |             ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:453:25
[INFO] [stdout]     |
[INFO] [stdout] 453 |                         try!(write!(f, "{:1$.2$}", datum, width, places));
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:456:25
[INFO] [stdout]     |
[INFO] [stdout] 456 |                         try!(write!(f, "{:1$}", datum, width));
[INFO] [stdout]     |                         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:460:21
[INFO] [stdout]     |
[INFO] [stdout] 460 |                     try!(write!(f, " "));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:469:17
[INFO] [stdout]     |
[INFO] [stdout] 469 |                 try!(write_row(f,
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:474:17
[INFO] [stdout]     |
[INFO] [stdout] 474 |                 try!(f.write_str("\n"));
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:476:21
[INFO] [stdout]     |
[INFO] [stdout] 476 |                     try!(write_row(f,
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/matrix/impl_mat.rs:481:21
[INFO] [stdout]     |
[INFO] [stdout] 481 |                     try!(f.write_str("\n"));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]   --> src/convert.rs:89:35
[INFO] [stdout]    |
[INFO] [stdout] 89 |         Ok(Matrix::<U>::new(m, n, try!(converted_data)))
[INFO] [stdout]    |                                   ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:138:9
[INFO] [stdout]     |
[INFO] [stdout] 138 |         try!(write!(f, "["));
[INFO] [stdout]     |         ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:142:21
[INFO] [stdout]     |
[INFO] [stdout] 142 |                     try!(write!(f, " {:.*}", places, datum));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:145:21
[INFO] [stdout]     |
[INFO] [stdout] 145 |                     try!(write!(f, " {}", datum));
[INFO] [stdout]     |                     ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated macro `try`: use the `?` operator instead
[INFO] [stdout]    --> src/vector/impl_vec.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 try!(write!(f, ","));
[INFO] [stdout]     |                 ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary trailing semicolon
[INFO] [stdout]    --> src/macros/matrix_eq.rs:967:90
[INFO] [stdout]     |
[INFO] [stdout] 967 |         assert_eq!(comp.compare(f64::NAN, 0.0), Err(UlpError(UlpComparisonResult::Nan)));;
[INFO] [stdout]     |                                                                                          ^ help: remove this semicolon
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(redundant_semicolons)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary trailing semicolon
[INFO] [stdout]     --> src/macros/matrix_eq.rs:1457:47
[INFO] [stdout]      |
[INFO] [stdout] 1457 |         assert_vector_eq!(x, x, comp = exact);;
[INFO] [stdout]      |                                               ^ help: remove this semicolon
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]     --> src/matrix/base/mod.rs:1579:28
[INFO] [stdout]      |
[INFO] [stdout] 1579 |     fn apply(mut self, f: &Fn(T) -> T) -> Self
[INFO] [stdout]      |                            ^^^^^^^^^^ help: use `dyn`: `dyn Fn(T) -> T`
[INFO] [stdout]      |
[INFO] [stdout]      = note: `#[warn(bare_trait_objects)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary trailing semicolon
[INFO] [stdout]    --> src/matrix/iter.rs:564:54
[INFO] [stdout]     |
[INFO] [stdout] 564 |         assert_eq!(5.0, *diags_iter.nth(1).unwrap());;
[INFO] [stdout]     |                                                      ^ help: remove this semicolon
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]   --> src/error.rs:13:16
[INFO] [stdout]    |
[INFO] [stdout] 13 |     error: Box<error::Error + Send + Sync>,
[INFO] [stdout]    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn error::Error + Send + Sync`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]   --> src/error.rs:39:27
[INFO] [stdout]    |
[INFO] [stdout] 39 |         where E: Into<Box<error::Error + Send + Sync>>
[INFO] [stdout]    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `dyn`: `dyn error::Error + Send + Sync`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: trait objects without an explicit `dyn` are deprecated
[INFO] [stdout]    --> src/vector/impl_vec.rs:185:32
[INFO] [stdout]     |
[INFO] [stdout] 185 |     pub fn apply(mut self, f: &Fn(T) -> T) -> Vector<T> {
[INFO] [stdout]     |                                ^^^^^^^^^^ help: use `dyn`: `dyn Fn(T) -> T`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 37 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary trailing semicolon
[INFO] [stdout]   --> tests/mat/mod.rs:36:55
[INFO] [stdout]    |
[INFO] [stdout] 36 |     assert!(a.solve_u_triangular(vector![]).is_err());;
[INFO] [stdout]    |                                                       ^ help: remove this semicolon
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(redundant_semicolons)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:5:13
[INFO] [stdout]    |
[INFO] [stdout] 5  |       let a = matrix![-4.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0;
[INFO] [stdout]    |  _____________^
[INFO] [stdout] 6  | |                     1.0, -4.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 7  | |                     0.0, 1.0, -4.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 8  | |                     1.0, 0.0, 0.0, -4.0, 1.0, 0.0, 1.0, 0.0, 0.0;
[INFO] [stdout] ...  |
[INFO] [stdout] 12 | |                     0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, -4.0, 1.0;
[INFO] [stdout] 13 | |                     0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, -4.0];
[INFO] [stdout]    | |_________________________________________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:29:13
[INFO] [stdout]    |
[INFO] [stdout] 29 |     let a = matrix![0.0];
[INFO] [stdout]    |             ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:38:13
[INFO] [stdout]    |
[INFO] [stdout] 38 |     let a = matrix![0.0];
[INFO] [stdout]    |             ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:45:13
[INFO] [stdout]    |
[INFO] [stdout] 45 |       let a = matrix![1., 3., 5.;
[INFO] [stdout]    |  _____________^
[INFO] [stdout] 46 | |                     2., 4., 7.;
[INFO] [stdout] 47 | |                     1., 1., 0.];
[INFO] [stdout]    | |_______________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:59:13
[INFO] [stdout]    |
[INFO] [stdout] 59 |       let b = matrix![1., 2., 3., 4., 5.;
[INFO] [stdout]    |  _____________^
[INFO] [stdout] 60 | |                     3., 0., 4., 5., 6.;
[INFO] [stdout] 61 | |                     2., 1., 2., 3., 4.;
[INFO] [stdout] 62 | |                     0., 0., 0., 6., 5.;
[INFO] [stdout] 63 | |                     0., 0., 0., 5., 6.];
[INFO] [stdout]    | |_______________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:72:13
[INFO] [stdout]    |
[INFO] [stdout] 72 |       let c = matrix![-4.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0;
[INFO] [stdout]    |  _____________^
[INFO] [stdout] 73 | |                     1.0, -4.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 74 | |                     0.0, 1.0, -4.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 75 | |                     1.0, 0.0, 0.0, -4.0, 1.0, 0.0, 1.0, 0.0, 0.0;
[INFO] [stdout] ...  |
[INFO] [stdout] 79 | |                     0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, -4.0, 1.0;
[INFO] [stdout] 80 | |                     0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, -4.0];
[INFO] [stdout]    | |_________________________________________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> tests/mat/mod.rs:84:13
[INFO] [stdout]    |
[INFO] [stdout] 84 |       let d = matrix![1.0, 1.0, 0.0, 0.0;
[INFO] [stdout]    |  _____________^
[INFO] [stdout] 85 | |                     0.0, 0.0, 1.0, 0.0;
[INFO] [stdout] 86 | |                     -1.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 87 | |                     0.0, 0.0, 0.0, 1.0];
[INFO] [stdout]    | |_______________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:106:17
[INFO] [stdout]     |
[INFO] [stdout] 106 |           let a = matrix![1., 3., 5.;
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 107 | |                         2., 4., 7.;
[INFO] [stdout] 108 | |                         1., 1., 0.];
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:114:22
[INFO] [stdout]     |
[INFO] [stdout] 114 |           let l_true = matrix![1.0,  0.0,  0.0;
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 115 | |                              0.5,  1.0,  0.0;
[INFO] [stdout] 116 | |                              0.5, -1.0,  1.0];
[INFO] [stdout]     | |_____________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:117:22
[INFO] [stdout]     |
[INFO] [stdout] 117 |           let u_true = matrix![2.0,  4.0,  7.0;
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 118 | |                              0.0,  1.0,  1.5;
[INFO] [stdout] 119 | |                              0.0,  0.0, -2.0];
[INFO] [stdout]     | |_____________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:120:22
[INFO] [stdout]     |
[INFO] [stdout] 120 |           let p_true = matrix![0.0, 1.0, 0.0;
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 121 | |                             1.0, 0.0, 0.0;
[INFO] [stdout] 122 | |                             0.0, 0.0, 1.0];
[INFO] [stdout]     | |__________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:130:17
[INFO] [stdout]     |
[INFO] [stdout] 130 |           let b = matrix![1., 2., 3., 4., 5.;
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 131 | |                         3., 0., 4., 5., 6.;
[INFO] [stdout] 132 | |                         2., 1., 2., 3., 4.;
[INFO] [stdout] 133 | |                         0., 0., 0., 6., 5.;
[INFO] [stdout] 134 | |                         0., 0., 0., 5., 6.];
[INFO] [stdout]     | |___________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:145:17
[INFO] [stdout]     |
[INFO] [stdout] 145 |           let c = matrix![-4.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0;
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 146 | |                         1.0, -4.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 147 | |                         0.0, 1.0, -4.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 148 | |                         1.0, 0.0, 0.0, -4.0, 1.0, 0.0, 1.0, 0.0, 0.0;
[INFO] [stdout] ...   |
[INFO] [stdout] 152 | |                         0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, -4.0, 1.0;
[INFO] [stdout] 153 | |                         0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, -4.0];
[INFO] [stdout]     | |_____________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:163:17
[INFO] [stdout]     |
[INFO] [stdout] 163 |           let d = matrix![1.0, 1.0, 0.0, 0.0;
[INFO] [stdout]     |  _________________^
[INFO] [stdout] 164 | |                         0.0, 0.0, 1.0, 0.0;
[INFO] [stdout] 165 | |                         -1.0, 0.0, 0.0, 0.0;
[INFO] [stdout] 166 | |                         0.0, 0.0, 0.0, 1.0];
[INFO] [stdout]     | |___________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:177:13
[INFO] [stdout]     |
[INFO] [stdout] 177 |       let a = matrix![25., 15., -5.;
[INFO] [stdout]     |  _____________^
[INFO] [stdout] 178 | |                     15., 18., 0.;
[INFO] [stdout] 179 | |                     -5., 0., 11.];
[INFO] [stdout]     | |_________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:190:13
[INFO] [stdout]     |
[INFO] [stdout] 190 |       let a = matrix![12., -51., 4.;
[INFO] [stdout]     |  _____________^
[INFO] [stdout] 191 | |                     6., 167., -68.;
[INFO] [stdout] 192 | |                     -4., 24., -41.];
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:202:18
[INFO] [stdout]     |
[INFO] [stdout] 202 |       let true_q = matrix![-0.857143, 0.394286, 0.331429;
[INFO] [stdout]     |  __________________^
[INFO] [stdout] 203 | |                          -0.428571, -0.902857, -0.034286;
[INFO] [stdout] 204 | |                          0.285715, -0.171429, 0.942857];
[INFO] [stdout]     | |_______________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> tests/mat/mod.rs:205:18
[INFO] [stdout]     |
[INFO] [stdout] 205 |       let true_r = matrix![-14., -21., 14.;
[INFO] [stdout]     |  __________________^
[INFO] [stdout] 206 | |                          0., -175., 70.;
[INFO] [stdout] 207 | |                          0., 0., -35.];
[INFO] [stdout]     | |______________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 19 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]      |
[INFO] [stdout] 671  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1241 |         assert_matrix_eq!(x, x);
[INFO] [stdout]      |         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]      |
[INFO] [stdout] 671  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1248 |         assert_matrix_eq!(x, x);
[INFO] [stdout]      |         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]      |
[INFO] [stdout] 671  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1308 |         assert_matrix_eq!(&x, &x);
[INFO] [stdout]      |         -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/slice.rs:180:9
[INFO] [stdout]     |
[INFO] [stdout] 180 |         assert_matrix_eq!(a, exp);
[INFO] [stdout]     |         -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:538:9
[INFO] [stdout]     |
[INFO] [stdout] 538 |         assert_matrix_eq!(expected_matrix, p.as_matrix());
[INFO] [stdout]     |         -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:687:9
[INFO] [stdout]     |
[INFO] [stdout] 687 |         assert_matrix_eq!(output, matrix![ 3; 1; 0; 2]);
[INFO] [stdout]     |         ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:698:9
[INFO] [stdout]     |
[INFO] [stdout] 698 |         assert_matrix_eq!(x, matrix![ 3; 1; 0; 2]);
[INFO] [stdout]     |         ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:707:9
[INFO] [stdout]     |
[INFO] [stdout] 707 |         assert_matrix_eq!(output, matrix![ 3, 1, 0, 2]);
[INFO] [stdout]     |         ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:715:9
[INFO] [stdout]     |
[INFO] [stdout] 715 |         assert_matrix_eq!(x, matrix![ 3, 1, 0, 2]);
[INFO] [stdout]     |         ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:202:9
[INFO] [stdout]     |
[INFO] [stdout] 202 |         assert_matrix_eq!(y, expected);
[INFO] [stdout]     |         ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:212:9
[INFO] [stdout]     |
[INFO] [stdout] 212 |         assert_matrix_eq!(y, expected);
[INFO] [stdout]     |         ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:224:13
[INFO] [stdout]     |
[INFO] [stdout] 224 |             assert_matrix_eq!(y, expected);
[INFO] [stdout]     |             ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:254:13
[INFO] [stdout]     |
[INFO] [stdout] 254 |             assert_matrix_eq!(y, expected);
[INFO] [stdout]     |             ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:278:13
[INFO] [stdout]     |
[INFO] [stdout] 278 |             assert_matrix_eq!(y, expected);
[INFO] [stdout]     |             ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:288:13
[INFO] [stdout]     |
[INFO] [stdout] 288 |             assert_matrix_eq!(y, expected);
[INFO] [stdout]     |             ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]   --> src/macros/matrix_eq.rs:94:61
[INFO] [stdout]    |
[INFO] [stdout] 94 |                 formatted_mismatches = formatted_mismatches.trim_right().to_string();
[INFO] [stdout]    |                                                             ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:187:61
[INFO] [stdout]     |
[INFO] [stdout] 187 |                 formatted_mismatches = formatted_mismatches.trim_right().to_string();
[INFO] [stdout]     |                                                             ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]      |
[INFO] [stdout] 755  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1423 |         assert_vector_eq!(x, x);
[INFO] [stdout]      |         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]      |
[INFO] [stdout] 755  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1429 |         assert_vector_eq!(x, x);
[INFO] [stdout]      |         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]      |
[INFO] [stdout] 755  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1437 |         assert_vector_eq!(x, y);
[INFO] [stdout]      |         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]      |
[INFO] [stdout] 755  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1445 |         assert_vector_eq!(x, y);
[INFO] [stdout]      |         ------------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]     --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]      |
[INFO] [stdout] 755  |                     msg = msg.trim_right());
[INFO] [stdout]      |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout] ...
[INFO] [stdout] 1574 |         assert_vector_eq!(&x, &x);
[INFO] [stdout]      |         -------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]     |
[INFO] [stdout] 755 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:724:9
[INFO] [stdout]     |
[INFO] [stdout] 724 |         assert_vector_eq!(output, vector![ 3, 1, 0, 2]);
[INFO] [stdout]     |         ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:755:31
[INFO] [stdout]     |
[INFO] [stdout] 755 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:732:9
[INFO] [stdout]     |
[INFO] [stdout] 732 |         assert_vector_eq!(x, vector![ 3, 1, 0, 2]);
[INFO] [stdout]     |         ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:173:13
[INFO] [stdout]     |
[INFO] [stdout] 173 |             assert_matrix_eq!(y, matrix![]);
[INFO] [stdout]     |             -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:179:13
[INFO] [stdout]     |
[INFO] [stdout] 179 |             assert_matrix_eq!(y, matrix![]);
[INFO] [stdout]     |             -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:185:13
[INFO] [stdout]     |
[INFO] [stdout] 185 |             assert_matrix_eq!(y, matrix![]);
[INFO] [stdout]     |             -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `core::str::<impl str>::trim_right`: superseded by `trim_end`
[INFO] [stdout]    --> src/macros/matrix_eq.rs:671:31
[INFO] [stdout]     |
[INFO] [stdout] 671 |                     msg = msg.trim_right());
[INFO] [stdout]     |                               ^^^^^^^^^^ help: replace the use of the deprecated associated function: `trim_end`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:191:13
[INFO] [stdout]     |
[INFO] [stdout] 191 |             assert_matrix_eq!(y, matrix![]);
[INFO] [stdout]     |             -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated associated function `std::error::Error::description`: use the Display impl or to_string()
[INFO] [stdout]   --> src/error.rs:55:20
[INFO] [stdout]    |
[INFO] [stdout] 55 |         self.error.description()
[INFO] [stdout]    |                    ^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/utils.rs:105:34
[INFO] [stdout]     |
[INFO] [stdout] 105 | pub fn in_place_vec_bin_op<F, T>(mut u: &mut [T], v: &[T], mut f: F)
[INFO] [stdout]     |                                  ----^
[INFO] [stdout]     |                                  |
[INFO] [stdout]     |                                  help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout] ...
[INFO] [stdout] 76 |               let mat = matrix![1, 2, 3;
[INFO] [stdout]    |  _______________________-
[INFO] [stdout] 77 | |                               4, 5, 6];
[INFO] [stdout]    | |______________________________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(array_into_iter)]` on by default
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout] ...
[INFO] [stdout] 85 |             let mat = matrix![1, 2, 3];
[INFO] [stdout]    |                       ---------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout] ...
[INFO] [stdout] 93 |             let mat = matrix![1];
[INFO] [stdout]    |                       ---------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout] ...
[INFO] [stdout] 101 |               let mat = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]     |  _______________________-
[INFO] [stdout] 102 | |                               4.0, 5.0, 6.0;
[INFO] [stdout] 103 | |                               7.0, 8.0, 9.0];
[INFO] [stdout]     | |____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1082:25
[INFO] [stdout]      |
[INFO] [stdout] 1082 |             let ref x = matrix![1];
[INFO] [stdout]      |                         ---------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1083:25
[INFO] [stdout]      |
[INFO] [stdout] 1083 |             let ref y = matrix![2];
[INFO] [stdout]      |                         ---------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1099:25
[INFO] [stdout]      |
[INFO] [stdout] 1099 |               let ref x = matrix![0, 1, 2;
[INFO] [stdout]      |  _________________________-
[INFO] [stdout] 1100 | |                                 3, 4, 5];
[INFO] [stdout]      | |________________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1101:25
[INFO] [stdout]      |
[INFO] [stdout] 1101 |               let ref y = matrix![1, 1, 2;
[INFO] [stdout]      |  _________________________-
[INFO] [stdout] 1102 | |                                 3, 4, 6];
[INFO] [stdout]      | |________________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1126:25
[INFO] [stdout]      |
[INFO] [stdout] 1126 |               let ref x = matrix![0, 1;
[INFO] [stdout]      |  _________________________-
[INFO] [stdout] 1127 | |                                 2, 3;
[INFO] [stdout] 1128 | |                                 4, 5];
[INFO] [stdout]      | |_____________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1129:25
[INFO] [stdout]      |
[INFO] [stdout] 1129 |               let ref y = matrix![1, 1;
[INFO] [stdout]      |  _________________________-
[INFO] [stdout] 1130 | |                                 2, 3;
[INFO] [stdout] 1131 | |                                 4, 6];
[INFO] [stdout]      | |_____________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1155:25
[INFO] [stdout]      |
[INFO] [stdout] 1155 |               let ref x = matrix![0, 1, 2, 3;
[INFO] [stdout]      |  _________________________-
[INFO] [stdout] 1156 | |                                 4, 5, 6, 7];
[INFO] [stdout]      | |___________________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1157:25
[INFO] [stdout]      |
[INFO] [stdout] 1157 |               let ref y = matrix![0, 1, 3, 3;
[INFO] [stdout]      |  _________________________-
[INFO] [stdout] 1158 | |                                 4, 6, 6, 7];
[INFO] [stdout]      | |___________________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1184:17
[INFO] [stdout]      |
[INFO] [stdout] 1184 |           let x = matrix![1, 2, 3;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1185 | |                         4, 5, 6];
[INFO] [stdout]      | |________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1191:17
[INFO] [stdout]      |
[INFO] [stdout] 1191 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1192 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1199:17
[INFO] [stdout]      |
[INFO] [stdout] 1199 |           let x = matrix![1, 2, 3;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1200 | |                         4, 5, 6];
[INFO] [stdout]      | |________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1201:17
[INFO] [stdout]      |
[INFO] [stdout] 1201 |           let y = matrix![1, 2;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1202 | |                         3, 4];
[INFO] [stdout]      | |_____________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1209:17
[INFO] [stdout]      |
[INFO] [stdout] 1209 |           let x = matrix![1.00,  2.00,  3.00;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1210 | |                         4.00,  5.00,  6.00];
[INFO] [stdout]      | |___________________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1211:17
[INFO] [stdout]      |
[INFO] [stdout] 1211 |           let y = matrix![1.00,  2.01,  3.00;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1212 | |                         3.99,  5.00,  6.00];
[INFO] [stdout]      | |___________________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1218:17
[INFO] [stdout]      |
[INFO] [stdout] 1218 |           let x = matrix![1, 2, 3;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1219 | |                         4, 5, 6];
[INFO] [stdout]      | |________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1225:17
[INFO] [stdout]      |
[INFO] [stdout] 1225 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1226 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1232:17
[INFO] [stdout]      |
[INFO] [stdout] 1232 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1233 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1239:17
[INFO] [stdout]      |
[INFO] [stdout] 1239 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1240 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1246:17
[INFO] [stdout]      |
[INFO] [stdout] 1246 |           let x = matrix![1, 2, 3;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1247 | |                         4, 5, 6];
[INFO] [stdout]      | |________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1254:17
[INFO] [stdout]      |
[INFO] [stdout] 1254 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1255 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1256:17
[INFO] [stdout]      |
[INFO] [stdout] 1256 |           let y = matrix![1.0, 2.0, -3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1257 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1265:17
[INFO] [stdout]      |
[INFO] [stdout] 1265 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1266 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1267:17
[INFO] [stdout]      |
[INFO] [stdout] 1267 |           let y = matrix![1.0, 2.0, f64::NAN;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1268 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1274:17
[INFO] [stdout]      |
[INFO] [stdout] 1274 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1275 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1281:17
[INFO] [stdout]      |
[INFO] [stdout] 1281 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1282 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1288:17
[INFO] [stdout]      |
[INFO] [stdout] 1288 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1289 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1295:17
[INFO] [stdout]      |
[INFO] [stdout] 1295 |           let x = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1296 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]      | |______________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/macros/matrix_eq.rs:1304:17
[INFO] [stdout]      |
[INFO] [stdout] 1304 |         let x = matrix![0.0f64];
[INFO] [stdout]      |                 --------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/bidiagonal.rs:131:19
[INFO] [stdout]     |
[INFO] [stdout] 131 |           let mat = matrix![1f64, 2.0, 3.0, 4.0, 5.0;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 132 | |                           2.0, 4.0, 1.0, 2.0, 1.0;
[INFO] [stdout] 133 | |                           3.0, 1.0, 7.0, 1.0, 1.0;
[INFO] [stdout] 134 | |                           4.0, 2.0, 1.0, -1.0, 3.0;
[INFO] [stdout] 135 | |                           5.0, 1.0, 1.0, 3.0, 2.0];
[INFO] [stdout]     | |__________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/bidiagonal.rs:142:19
[INFO] [stdout]     |
[INFO] [stdout] 142 |           let mat = matrix![1f64, 2.0, 3.0;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 143 | |                           4.0, 5.0, 2.0;
[INFO] [stdout] 144 | |                           4.0, 1.0, 2.0;
[INFO] [stdout] 145 | |                           1.0, 3.0, 1.0;
[INFO] [stdout] 146 | |                           7.0, 1.0, 1.0];
[INFO] [stdout]     | |________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/bidiagonal.rs:150:19
[INFO] [stdout]     |
[INFO] [stdout] 150 |           let mat = matrix![1f64, 2.0, 3.0, 4.0, 5.0;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 151 | |                           2.0, 4.0, 1.0, 2.0, 1.0;
[INFO] [stdout] 152 | |                           3.0, 1.0, 7.0, 1.0, 1.0];
[INFO] [stdout]     | |__________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/svd.rs:368:17
[INFO] [stdout]     |
[INFO] [stdout] 368 |           let u = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 369 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/svd.rs:370:17
[INFO] [stdout]     |
[INFO] [stdout] 370 |           let b = matrix![4.0, 0.0, 0.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 371 | |                         0.0, 8.0, 0.0;
[INFO] [stdout] 372 | |                         0.0, 0.0, 2.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/svd.rs:373:17
[INFO] [stdout]     |
[INFO] [stdout] 373 |           let v = matrix![21.0, 22.0, 23.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 374 | |                         24.0, 25.0, 26.0;
[INFO] [stdout] 375 | |                         27.0, 28.0, 29.0];
[INFO] [stdout]     | |_________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/svd.rs:390:19
[INFO] [stdout]     |
[INFO] [stdout] 390 |           let mat = matrix![3.61833700244349288, -3.28382346228211697,  1.97968027781346501, -0.41869628192662156;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 391 | |                           3.96046289599926427,  0.70730060716580723, -2.80552479438772817, -1.45283286109873933;
[INFO] [stdout] 392 | |                           1.44435028724617442,  1.27749196276785826, -1.09858397535426366, -0.03159619816434689;
[INFO] [stdout] 393 | |                           1.13455445826500667,  0.81521390274755756,  3.99123446373437263, -2.83025703359666192;
[INFO] [stdout] 394 | |                           -3.30895752093770579, -0.04979044289857298,  3.03248594516832792,  3.85962479743330977];
[INFO] [stdout]     | |_________________________________________________________________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/svd.rs:411:19
[INFO] [stdout]     |
[INFO] [stdout] 411 |           let mat = matrix![3.61833700244349288,  3.96046289599926427,  1.44435028724617442,  1.13455445826500645, -3.30895752093770579;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 412 | |                          -3.28382346228211697,  0.70730060716580723,  1.27749196276785826,  0.81521390274755756, -0.04979044289857298;
[INFO] [stdout] 413 | |                           1.97968027781346545, -2.80552479438772817, -1.09858397535426366,  3.99123446373437263,  3.03248594516832792;
[INFO] [stdout] 414 | |                          -0.41869628192662156, -1.45283286109873933, -0.03159619816434689, -2.83025703359666192,  3.85962479743330977];
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/svd.rs:429:19
[INFO] [stdout]     |
[INFO] [stdout] 429 |           let mat = matrix![1.0,  2.0,  3.0,  4.0,  5.0;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 430 | |                           2.0,  4.0,  1.0,  2.0,  1.0;
[INFO] [stdout] 431 | |                           3.0,  1.0,  7.0,  1.0,  1.0;
[INFO] [stdout] 432 | |                           4.0,  2.0,  1.0, -1.0,  3.0;
[INFO] [stdout] 433 | |                           5.0,  1.0,  1.0,  3.0,  2.0];
[INFO] [stdout]     | |______________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:457:30
[INFO] [stdout]     |
[INFO] [stdout] 457 |           let a: Matrix<f64> = matrix![
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 458 | |             1., 2., 3., 4.;
[INFO] [stdout] 459 | |             0., 0., 0., 0.;
[INFO] [stdout] 460 | |             0., 0., 0., 0.;
[INFO] [stdout] 461 | |             0., 0., 0., 0.
[INFO] [stdout] 462 | |         ];
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:477:17
[INFO] [stdout]     |
[INFO] [stdout] 477 |           let x = matrix![ -3.0,   0.0,   4.0,   1.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 478 | |                         -12.0,   5.0,  17.0,   1.0;
[INFO] [stdout] 479 | |                          15.0,   0.0, -18.0,  -5.0;
[INFO] [stdout] 480 | |                           6.0,  20.0, -10.0, -15.0 ];
[INFO] [stdout]     | |____________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:505:17
[INFO] [stdout]     |
[INFO] [stdout] 505 |           let x = matrix![5.0, 0.0, 0.0, 1.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 506 | |                         2.0, 2.0, 2.0, 1.0;
[INFO] [stdout] 507 | |                         4.0, 5.0, 5.0, 5.0;
[INFO] [stdout] 508 | |                         1.0, 6.0, 4.0, 5.0];
[INFO] [stdout]     | |___________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:510:19
[INFO] [stdout]     |
[INFO] [stdout] 510 |           let inv = matrix![1.85185185185185203e-01,   1.85185185185185175e-01, -7.40740740740740561e-02, -1.02798428206033007e-17;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 511 | |                           1.66666666666666630e-01,   6.66666666666666519e-01, -6.66666666666666519e-01,  4.99999999999999833e-01;
[INFO] [stdout] 512 | |                          -3.88888888888888840e-01,   1.11111111111111174e-01,  5.55555555555555358e-01, -4.99999999999999833e-01;
[INFO] [stdout] 513 | |                           7.40740740740740838e-02,  -9.25925925925925819e-01,  3.70370370370370294e-01,  5.13992141030165006e-17];
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:532:17
[INFO] [stdout]     |
[INFO] [stdout] 532 |           let x = matrix![ 5.0,  0.0,  0.0,  1.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 533 | |                          0.0,  2.0,  2.0,  1.0;
[INFO] [stdout] 534 | |                         15.0,  4.0,  7.0, 10.0;
[INFO] [stdout] 535 | |                          5.0,  2.0, 17.0, 32.0];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:546:17
[INFO] [stdout]     |
[INFO] [stdout] 546 |           let x = matrix![ 5.0, 0.0, 0.0, 1.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 547 | |                          2.0, 2.0, 2.0, 1.0;
[INFO] [stdout] 548 | |                          4.0, 5.0, 5.0, 5.0;
[INFO] [stdout] 549 | |                          1.0, 6.0, 4.0, 5.0 ];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:573:22
[INFO] [stdout]     |
[INFO] [stdout] 573 |             let lu = matrix![3.0];
[INFO] [stdout]     |                      ------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/lu.rs:580:22
[INFO] [stdout]     |
[INFO] [stdout] 580 |               let lu = matrix![3.0, 2.0;
[INFO] [stdout]     |  ______________________-
[INFO] [stdout] 581 | |                              2.0, 2.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/eigen.rs:377:17
[INFO] [stdout]     |
[INFO] [stdout] 377 |         let a = matrix![1., 2.; 3., 4.];
[INFO] [stdout]     |                 ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/eigen.rs:393:17
[INFO] [stdout]     |
[INFO] [stdout] 393 |         let a = matrix![1., -3.; 1., 1.];
[INFO] [stdout]     |                 ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/eigen.rs:402:17
[INFO] [stdout]     |
[INFO] [stdout] 402 |         let a = matrix![20., 4.; 20., 16.];
[INFO] [stdout]     |                 -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/eigen.rs:418:17
[INFO] [stdout]     |
[INFO] [stdout] 418 |           let a = matrix![17f64, 22., 27.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 419 | |                         22., 29., 36.;
[INFO] [stdout] 420 | |                         27., 36., 45.];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/decomposition/eigen.rs:435:17
[INFO] [stdout]     |
[INFO] [stdout] 435 |           let a = matrix![1f64, 2.0, 3.0, 4.0, 5.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 436 | |                         2.0, 4.0, 1.0, 2.0, 1.0;
[INFO] [stdout] 437 | |                         3.0, 1.0, 7.0, 1.0, 1.0;
[INFO] [stdout] 438 | |                         4.0, 2.0, 1.0, -1.0, 3.0;
[INFO] [stdout] 439 | |                         5.0, 1.0, 1.0, 3.0, 2.0];
[INFO] [stdout]     | |________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/base/impl_base.rs:307:17
[INFO] [stdout]     |
[INFO] [stdout] 307 |           let a = matrix![0.0, 1.0, 2.0, 3.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 308 | |                         4.0, 5.0, 6.0, 7.0;
[INFO] [stdout] 309 | |                         8.0, 9.0, 10.0, 11.0];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/base/impl_base.rs:319:17
[INFO] [stdout]     |
[INFO] [stdout] 319 |           let a = matrix![0.0, 1.0, 2.0, 3.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 320 | |                         4.0, 5.0, 6.0, 7.0;
[INFO] [stdout] 321 | |                         8.0, 9.0, 10.0, 11.0];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/base/impl_base.rs:431:17
[INFO] [stdout]     |
[INFO] [stdout] 431 |           let a = matrix![1., 3., 5.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 432 | |                         2., 4., 7.;
[INFO] [stdout] 433 | |                         1., 1., 0.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/base/impl_base.rs:439:17
[INFO] [stdout]     |
[INFO] [stdout] 439 |           let c = matrix![1., 0., 0.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 440 | |                         0., 2., 0.;
[INFO] [stdout] 441 | |                         0., 0., 3.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/base/impl_base.rs:449:17
[INFO] [stdout]     |
[INFO] [stdout] 449 |           let a = matrix![1., 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 450 | |                         3., 4.;
[INFO] [stdout] 451 | |                         5., 6.;
[INFO] [stdout] 452 | |                         7., 8.;
[INFO] [stdout] 453 | |                         9., 10.];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:532:17
[INFO] [stdout]     |
[INFO] [stdout] 532 |           let a = matrix![1., 2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 533 | |                         4., 5., 6.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:549:28
[INFO] [stdout]     |
[INFO] [stdout] 549 |           let first_matrix = matrix![1, 2, 3;
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 550 | |                                    4, 5, 6];
[INFO] [stdout]     | |___________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:554:29
[INFO] [stdout]     |
[INFO] [stdout] 554 |           let second_matrix = matrix![3.14, 2.718, 1.414;
[INFO] [stdout]     |  _____________________________-
[INFO] [stdout] 555 | |                                     2.503, 4.669, 1.202;
[INFO] [stdout] 556 | |                                     1.618, 0.5772, 1.3;
[INFO] [stdout] 557 | |                                     2.68545, 1.282, 10000.];
[INFO] [stdout]     | |___________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:565:30
[INFO] [stdout]     |
[INFO] [stdout] 565 |         let one_row_matrix = matrix![1, 2, 3, 4];
[INFO] [stdout]     |                              ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:571:26
[INFO] [stdout]     |
[INFO] [stdout] 571 |           let our_matrix = matrix![1.2, 1.23, 1.234;
[INFO] [stdout]     |  __________________________-
[INFO] [stdout] 572 | |                                  1.2345, 1.23456, 1.234567];
[INFO] [stdout]     | |___________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:628:17
[INFO] [stdout]     |
[INFO] [stdout] 628 |           let a = matrix![1., 3., 5.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 629 | |                         2., 4., 7.;
[INFO] [stdout] 630 | |                         1., 1., 0.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:636:17
[INFO] [stdout]     |
[INFO] [stdout] 636 |           let c = matrix![1., 0., 0.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 637 | |                         0., 2., 0.;
[INFO] [stdout] 638 | |                         0., 0., 3.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:646:17
[INFO] [stdout]     |
[INFO] [stdout] 646 |           let a = matrix![2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 647 | |                         1., 2.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:652:17
[INFO] [stdout]     |
[INFO] [stdout] 652 |           let c = matrix![1., 2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 653 | |                         4., 5., 6.;
[INFO] [stdout] 654 | |                         7., 8., 9.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:659:30
[INFO] [stdout]     |
[INFO] [stdout] 659 |           let e: Matrix<f64> = matrix![1., 2., 3., 4., 5.;
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 660 | |                                      3., 0., 4., 5., 6.;
[INFO] [stdout] 661 | |                                      2., 1., 2., 3., 4.;
[INFO] [stdout] 662 | |                                      0., 0., 0., 6., 5.;
[INFO] [stdout] 663 | |                                      0., 0., 0., 5., 6.];
[INFO] [stdout]     | |________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:671:30
[INFO] [stdout]     |
[INFO] [stdout] 671 |           let g: Matrix<f64> = matrix![1., 2., 3., 4.;
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 672 | |                                      0., 0., 0., 0.;
[INFO] [stdout] 673 | |                                      0., 0., 0., 0.;
[INFO] [stdout] 674 | |                                      0., 0., 0., 0.];
[INFO] [stdout]     | |____________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:681:17
[INFO] [stdout]     |
[INFO] [stdout] 681 |           let a = matrix![2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 682 | |                         1., 2.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:756:30
[INFO] [stdout]     |
[INFO] [stdout] 756 |         let a: Matrix<f32> = matrix![1.0, 2.0];
[INFO] [stdout]     |                              ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_mat.rs:765:30
[INFO] [stdout]     |
[INFO] [stdout] 765 |         let b: Matrix<f32> = matrix![1.0; 2.0];
[INFO] [stdout]     |                              ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_ops.rs:894:17
[INFO] [stdout]     |
[INFO] [stdout] 894 |           let a = matrix![1., 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 895 | |                         3., 4.;
[INFO] [stdout] 896 | |                         5., 6.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_ops.rs:908:17
[INFO] [stdout]     |
[INFO] [stdout] 908 |           let a = matrix![1., 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 909 | |                         3., 4.;
[INFO] [stdout] 910 | |                         5., 6.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_ops.rs:924:17
[INFO] [stdout]     |
[INFO] [stdout] 924 |           let a = matrix![1., 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 925 | |                         3., 4.;
[INFO] [stdout] 926 | |                         5., 6.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_ops.rs:971:17
[INFO] [stdout]     |
[INFO] [stdout] 971 |           let a = matrix![1., 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 972 | |                         3., 4.;
[INFO] [stdout] 973 | |                         5., 6.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_ops.rs:974:17
[INFO] [stdout]     |
[INFO] [stdout] 974 |           let b = matrix![2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 975 | |                         4., 5.;
[INFO] [stdout] 976 | |                         6., 7.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/impl_ops.rs:1021:17
[INFO] [stdout]      |
[INFO] [stdout] 1021 |           let a = matrix![1., 2.;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1022 | |                         3., 4.;
[INFO] [stdout] 1023 | |                         5., 6.];
[INFO] [stdout]      | |_______________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/impl_ops.rs:1069:17
[INFO] [stdout]      |
[INFO] [stdout] 1069 |           let a = matrix![1., 2.;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1070 | |                         3., 4.;
[INFO] [stdout] 1071 | |                         5., 6.];
[INFO] [stdout]      | |_______________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/impl_ops.rs:1072:17
[INFO] [stdout]      |
[INFO] [stdout] 1072 |           let b = matrix![2., 3.;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1073 | |                         4., 5.;
[INFO] [stdout] 1074 | |                         6., 7.];
[INFO] [stdout]      | |_______________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/impl_ops.rs:1119:17
[INFO] [stdout]      |
[INFO] [stdout] 1119 |           let a = matrix![1., 2.;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1120 | |                         3., 4.;
[INFO] [stdout] 1121 | |                         5., 6.];
[INFO] [stdout]      | |_______________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/impl_ops.rs:1167:17
[INFO] [stdout]      |
[INFO] [stdout] 1167 |           let a = matrix![1., 2.;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1168 | |                         3., 4.;
[INFO] [stdout] 1169 | |                         5., 6.];
[INFO] [stdout]      | |_______________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:448:17
[INFO] [stdout]     |
[INFO] [stdout] 448 |           let a = matrix![0.0, 1.0, 2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 449 | |                         3.0, 4.0, 5.0;
[INFO] [stdout] 450 | |                         6.0, 7.0, 8.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:469:21
[INFO] [stdout]     |
[INFO] [stdout] 469 |           let mut a = matrix![0.0, 1.0, 2.0;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 470 | |                             3.0, 4.0, 5.0;
[INFO] [stdout] 471 | |                             6.0, 7.0, 8.0];
[INFO] [stdout]     | |__________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:505:21
[INFO] [stdout]     |
[INFO] [stdout] 505 |           let mut a = matrix![0.0, 1.0, 2.0, 3.0;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 506 | |                             4.0, 5.0, 6.0, 7.0;
[INFO] [stdout] 507 | |                             8.0, 9.0, 10.0, 11.0];
[INFO] [stdout]     | |_________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:537:17
[INFO] [stdout]     |
[INFO] [stdout] 537 |           let a = matrix![0.0, 1.0, 2.0, 3.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 538 | |                         4.0, 5.0, 6.0, 7.0;
[INFO] [stdout] 539 | |                         8.0, 9.0, 10.0, 11.0];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:558:17
[INFO] [stdout]     |
[INFO] [stdout] 558 |           let a = matrix![0.0, 1.0, 2.0, 3.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 559 | |                         4.0, 5.0, 6.0, 7.0;
[INFO] [stdout] 560 | |                         8.0, 9.0, 10.0, 11.0];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:578:17
[INFO] [stdout]     |
[INFO] [stdout] 578 |           let a = matrix![0.0, 1.0, 2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 579 | |                         3.0, 4.0, 5.0;
[INFO] [stdout] 580 | |                         6.0, 7.0, 8.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:594:17
[INFO] [stdout]     |
[INFO] [stdout] 594 |           let a = matrix![0.0, 1.0, 2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 595 | |                         3.0, 4.0, 5.0;
[INFO] [stdout] 596 | |                         6.0, 7.0, 8.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:617:17
[INFO] [stdout]     |
[INFO] [stdout] 617 |           let a = matrix![0.0, 1.0, 2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 618 | |                         3.0, 4.0, 5.0;
[INFO] [stdout] 619 | |                         6.0, 7.0, 8.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:634:17
[INFO] [stdout]     |
[INFO] [stdout] 634 |           let a = matrix![0.0, 1.0, 2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 635 | |                         3.0, 4.0, 5.0;
[INFO] [stdout] 636 | |                         6.0, 7.0, 8.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:653:21
[INFO] [stdout]     |
[INFO] [stdout] 653 |           let mut a = matrix![0, 1, 2, 3;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 654 | |                             4, 5, 6, 7;
[INFO] [stdout] 655 | |                             8, 9, 10, 11];
[INFO] [stdout]     | |_________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:681:17
[INFO] [stdout]     |
[INFO] [stdout] 681 |           let a = matrix![0, 1, 2, 3;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 682 | |                         4, 5, 6, 7;
[INFO] [stdout] 683 | |                         8, 9, 10, 11];
[INFO] [stdout]     | |_____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:698:21
[INFO] [stdout]     |
[INFO] [stdout] 698 |           let mut a = matrix![0, 1, 2, 3;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 699 | |                             4, 5, 6, 7;
[INFO] [stdout] 700 | |                             8, 9, 10, 11];
[INFO] [stdout]     | |_________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:731:17
[INFO] [stdout]     |
[INFO] [stdout] 731 |           let a = matrix![0, 1, 2, 3;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 732 | |                         4, 5, 6, 7;
[INFO] [stdout] 733 | |                         8, 9, 10, 11];
[INFO] [stdout]     | |_____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:754:17
[INFO] [stdout]     |
[INFO] [stdout] 754 |           let a = matrix![0, 1, 2, 3;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 755 | |                         4, 5, 6, 7;
[INFO] [stdout] 756 | |                         8, 9, 10, 11];
[INFO] [stdout]     | |_____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:786:17
[INFO] [stdout]     |
[INFO] [stdout] 786 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 787 | |                         3, 4, 5;
[INFO] [stdout] 788 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:801:17
[INFO] [stdout]     |
[INFO] [stdout] 801 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 802 | |                         3, 4, 5;
[INFO] [stdout] 803 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:823:21
[INFO] [stdout]     |
[INFO] [stdout] 823 |           let mut a = matrix![0, 1, 2;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 824 | |                             3, 4, 5;
[INFO] [stdout] 825 | |                             6, 7, 8];
[INFO] [stdout]     | |____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:848:17
[INFO] [stdout]     |
[INFO] [stdout] 848 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 849 | |                         3, 4, 5;
[INFO] [stdout] 850 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:863:21
[INFO] [stdout]     |
[INFO] [stdout] 863 |           let mut a = matrix![0, 1, 2;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 864 | |                             3, 4, 5;
[INFO] [stdout] 865 | |                             6, 7, 8];
[INFO] [stdout]     | |____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:892:17
[INFO] [stdout]     |
[INFO] [stdout] 892 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 893 | |                         3, 4, 5;
[INFO] [stdout] 894 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:906:17
[INFO] [stdout]     |
[INFO] [stdout] 906 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 907 | |                         3, 4, 5;
[INFO] [stdout] 908 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:931:17
[INFO] [stdout]     |
[INFO] [stdout] 931 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 932 | |                         3, 4, 5;
[INFO] [stdout] 933 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/iter.rs:946:17
[INFO] [stdout]     |
[INFO] [stdout] 946 |           let a = matrix![0, 1, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 947 | |                         3, 4, 5;
[INFO] [stdout] 948 | |                         6, 7, 8];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/iter.rs:1012:21
[INFO] [stdout]      |
[INFO] [stdout] 1012 |             let x = matrix![ 1 ];
[INFO] [stdout]      |                     ------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/iter.rs:1019:21
[INFO] [stdout]      |
[INFO] [stdout] 1019 |             let x = matrix![ 1, 2 ];
[INFO] [stdout]      |                     --------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/iter.rs:1027:21
[INFO] [stdout]      |
[INFO] [stdout] 1027 |             let x = matrix![ 1; 2 ];
[INFO] [stdout]      |                     --------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/iter.rs:1035:21
[INFO] [stdout]      |
[INFO] [stdout] 1035 |               let x = matrix![ 1, 2;
[INFO] [stdout]      |  _____________________-
[INFO] [stdout] 1036 | |                              3, 4 ];
[INFO] [stdout]      | |___________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]     --> src/macros/matrix.rs:59:67
[INFO] [stdout]      |
[INFO] [stdout] 59   |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]      |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]      | 
[INFO] [stdout]     ::: src/matrix/iter.rs:1048:17
[INFO] [stdout]      |
[INFO] [stdout] 1048 |           let x = matrix![1, 2, 3;
[INFO] [stdout]      |  _________________-
[INFO] [stdout] 1049 | |                         4, 5, 6;
[INFO] [stdout] 1050 | |                         7, 8, 9];
[INFO] [stdout]      | |________________________________- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]      = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]      = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:295:17
[INFO] [stdout]     |
[INFO] [stdout] 295 |           let a = matrix![1f32, 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 296 | |                         3., 4.;
[INFO] [stdout] 297 | |                         5., 6.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:298:17
[INFO] [stdout]     |
[INFO] [stdout] 298 |           let b = matrix![1f32, 2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 299 | |                         4., 5., 6.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:320:17
[INFO] [stdout]     |
[INFO] [stdout] 320 |           let a = matrix![1f64, 2.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 321 | |                         3., 4.;
[INFO] [stdout] 322 | |                         5., 6.];
[INFO] [stdout]     | |_______________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:323:17
[INFO] [stdout]     |
[INFO] [stdout] 323 |           let b = matrix![1f64, 2., 3.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 324 | |                         4., 5., 6.];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:345:17
[INFO] [stdout]     |
[INFO] [stdout] 345 |           let a = matrix![1usize, 2;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 346 | |                         3, 4;
[INFO] [stdout] 347 | |                         5, 6];
[INFO] [stdout]     | |_____________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:348:17
[INFO] [stdout]     |
[INFO] [stdout] 348 |           let b = matrix![1usize, 2, 3;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 349 | |                         4, 5, 6];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:400:17
[INFO] [stdout]     |
[INFO] [stdout] 400 |         let a = matrix![1.0, 2.0; 3.0, 4.0];
[INFO] [stdout]     |                 --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:402:17
[INFO] [stdout]     |
[INFO] [stdout] 402 |           let c = matrix![1.0, 2.0, 3.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 403 | |                         4.0, 5.0, 6.0];
[INFO] [stdout]     | |______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:416:17
[INFO] [stdout]     |
[INFO] [stdout] 416 |         let a = matrix![1usize, 2; 3, 4];
[INFO] [stdout]     |                 ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/mat_mul.rs:418:17
[INFO] [stdout]     |
[INFO] [stdout] 418 |         let c = matrix![1usize, 2, 3; 4, 5, 6];
[INFO] [stdout]     |                 ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/slice.rs:177:19
[INFO] [stdout]     |
[INFO] [stdout] 177 |           let exp = matrix![2.0, 2.0, 2.0;
[INFO] [stdout]     |  ___________________-
[INFO] [stdout] 178 | |                           2.0, 4.0, 4.0;
[INFO] [stdout] 179 | |                           2.0, 4.0, 4.0];
[INFO] [stdout]     | |________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/slice.rs:186:17
[INFO] [stdout]     |
[INFO] [stdout] 186 |           let a = matrix![1., 3., 5., 4.;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 187 | |                         2., 4., 7., 1.;
[INFO] [stdout] 188 | |                         1., 1., 0., 0.];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/slice.rs:195:17
[INFO] [stdout]     |
[INFO] [stdout] 195 |         let r = matrix![1., 3., 5., 4.];
[INFO] [stdout]     |                 ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/slice.rs:202:17
[INFO] [stdout]     |
[INFO] [stdout] 202 |         let c = matrix![1.; 2.; 3.];
[INFO] [stdout]     |                 ------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/slice.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 209 |         let t = matrix![1., 2.; 0., 1.];
[INFO] [stdout]     |                 ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:533:44
[INFO] [stdout]     |
[INFO] [stdout] 533 |           let expected_matrix: Matrix<u32> = matrix![0, 0, 1, 0;
[INFO] [stdout]     |  ____________________________________________-
[INFO] [stdout] 534 | |                                                    0, 1, 0, 0;
[INFO] [stdout] 535 | |                                                    1, 0, 0, 0;
[INFO] [stdout] 536 | |                                                    0, 0, 0, 1];
[INFO] [stdout]     | |______________________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:680:17
[INFO] [stdout]     |
[INFO] [stdout] 680 |           let x = matrix![ 0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 681 | |                          1;
[INFO] [stdout] 682 | |                          2;
[INFO] [stdout] 683 | |                          3];
[INFO] [stdout]     | |___________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:687:35
[INFO] [stdout]     |
[INFO] [stdout] 687 |         assert_matrix_eq!(output, matrix![ 3; 1; 0; 2]);
[INFO] [stdout]     |                                   -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:692:21
[INFO] [stdout]     |
[INFO] [stdout] 692 |           let mut x = matrix![ 0;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 693 | |                          1;
[INFO] [stdout] 694 | |                          2;
[INFO] [stdout] 695 | |                          3];
[INFO] [stdout]     | |___________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:698:30
[INFO] [stdout]     |
[INFO] [stdout] 698 |         assert_matrix_eq!(x, matrix![ 3; 1; 0; 2]);
[INFO] [stdout]     |                              -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:703:17
[INFO] [stdout]     |
[INFO] [stdout] 703 |         let x = matrix![ 0, 1, 2, 3];
[INFO] [stdout]     |                 -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:707:35
[INFO] [stdout]     |
[INFO] [stdout] 707 |         assert_matrix_eq!(output, matrix![ 3, 1, 0, 2]);
[INFO] [stdout]     |                                   -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:712:21
[INFO] [stdout]     |
[INFO] [stdout] 712 |         let mut x = matrix![ 0, 1, 2, 3];
[INFO] [stdout]     |                     -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/permutation_matrix.rs:715:30
[INFO] [stdout]     |
[INFO] [stdout] 715 |         assert_matrix_eq!(x, matrix![ 3, 1, 0, 2]);
[INFO] [stdout]     |                              -------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:285:17
[INFO] [stdout]     |
[INFO] [stdout] 285 |           let x = matrix![1, 2, 3;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 286 | |                         4, 5, 6;
[INFO] [stdout] 287 | |                         7, 8, 9];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:288:24
[INFO] [stdout]     |
[INFO] [stdout] 288 |           let expected = matrix![7, 8, 9;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 289 | |                                1, 2, 3;
[INFO] [stdout] 290 | |                                4, 5, 6];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:320:24
[INFO] [stdout]     |
[INFO] [stdout] 320 |           let x_source = matrix![1, 2, 3;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 321 | |                                4, 5, 6;
[INFO] [stdout] 322 | |                                7, 8, 9];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:323:24
[INFO] [stdout]     |
[INFO] [stdout] 323 |           let expected = matrix![7, 8, 9;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 324 | |                                1, 2, 3;
[INFO] [stdout] 325 | |                                4, 5, 6];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:391:17
[INFO] [stdout]     |
[INFO] [stdout] 391 |           let x = matrix![1, 2, 3;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 392 | |                         4, 5, 6;
[INFO] [stdout] 393 | |                         7, 8, 9];
[INFO] [stdout]     | |________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:394:24
[INFO] [stdout]     |
[INFO] [stdout] 394 |           let expected = matrix![3, 1, 2;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 395 | |                                6, 4, 5;
[INFO] [stdout] 396 | |                                9, 7, 8];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:426:24
[INFO] [stdout]     |
[INFO] [stdout] 426 |           let x_source = matrix![1, 2, 3;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 427 | |                                4, 5, 6;
[INFO] [stdout] 428 | |                                7, 8, 9];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/matrix/impl_permutation_mul.rs:429:24
[INFO] [stdout]     |
[INFO] [stdout] 429 |           let expected = matrix![3, 1, 2;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 430 | |                                6, 4, 5;
[INFO] [stdout] 431 | |                                9, 7, 8];
[INFO] [stdout]     | |_______________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:197:30
[INFO] [stdout]     |
[INFO] [stdout] 197 |           let x: Matrix<f64> = matrix![ 1.0, 2.0;
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 198 | |                                      -3.0, 4.0];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:200:24
[INFO] [stdout]     |
[INFO] [stdout] 200 |           let expected = matrix![ 1, 2;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 201 | |                                -3, 4];
[INFO] [stdout]     | |_____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:207:30
[INFO] [stdout]     |
[INFO] [stdout] 207 |           let x: Matrix<f64> = matrix![ 1.0, 2.0;
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 208 | |                                       3.0, 4.0];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:210:24
[INFO] [stdout]     |
[INFO] [stdout] 210 |           let expected = matrix![ 1, 2;
[INFO] [stdout]     |  ________________________-
[INFO] [stdout] 211 | |                                 3, 4];
[INFO] [stdout]     | |_____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:218:34
[INFO] [stdout]     |
[INFO] [stdout] 218 |               let x: Matrix<i64> = matrix![ 1, 2;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 219 | |                                          -3, 4];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:222:28
[INFO] [stdout]     |
[INFO] [stdout] 222 |               let expected = matrix![ 1.0, 2.0;
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 223 | |                                    -3.0, 4.0];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:232:38
[INFO] [stdout]     |
[INFO] [stdout] 232 |                 let x: Matrix<i64> = matrix![1, 2, i64::max_value()];
[INFO] [stdout]     |                                      ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:238:38
[INFO] [stdout]     |
[INFO] [stdout] 238 |                 let x: Matrix<i64> = matrix![1, 2, i64::min_value()];
[INFO] [stdout]     |                                      ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:248:34
[INFO] [stdout]     |
[INFO] [stdout] 248 |               let x: Matrix<u64> = matrix![ 1, 2;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 249 | |                                           3, 4];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:252:28
[INFO] [stdout]     |
[INFO] [stdout] 252 |               let expected = matrix![ 1.0, 2.0;
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 253 | |                                     3.0, 4.0];
[INFO] [stdout]     | |_____________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:262:38
[INFO] [stdout]     |
[INFO] [stdout] 262 |                 let x: Matrix<u64> = matrix![1, 2, u64::max_value()];
[INFO] [stdout]     |                                      ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:272:34
[INFO] [stdout]     |
[INFO] [stdout] 272 |               let x: Matrix<u64> = matrix![ 1, 2;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 273 | |                                           3, 4];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:276:28
[INFO] [stdout]     |
[INFO] [stdout] 276 |               let expected = matrix![ 1, 2;
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 277 | |                                     3, 4];
[INFO] [stdout]     | |_________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:282:34
[INFO] [stdout]     |
[INFO] [stdout] 282 |               let x: Matrix<i64> = matrix![ 1, 2;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 283 | |                                           3, 4];
[INFO] [stdout]     | |_______________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:286:28
[INFO] [stdout]     |
[INFO] [stdout] 286 |               let expected = matrix![ 1, 2;
[INFO] [stdout]     |  ____________________________-
[INFO] [stdout] 287 | |                                     3, 4];
[INFO] [stdout]     | |_________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:293:21
[INFO] [stdout]     |
[INFO] [stdout] 293 |               let x = matrix![ 1, -2;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 294 | |                              3,  4];
[INFO] [stdout]     | |___________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:302:30
[INFO] [stdout]     |
[INFO] [stdout] 302 |           let a: Matrix<i64> = matrix![1, 2, 3, 4;
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 303 | |                                      5, 6, 7, 8;
[INFO] [stdout] 304 | |                                      9, 10, 11, 12];
[INFO] [stdout]     | |___________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:316:34
[INFO] [stdout]     |
[INFO] [stdout] 316 |           let mut a: Matrix<i64> = matrix![1, 2, 3, 4;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 317 | |                                          5, 6, 7, 8;
[INFO] [stdout] 318 | |                                          9, 10, 11, 12];
[INFO] [stdout]     | |_______________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:324:34
[INFO] [stdout]     |
[INFO] [stdout] 324 |           let mut a: Matrix<i64> = matrix![1, 2, 3, 4;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 325 | |                                          5, 6, 7, 8;
[INFO] [stdout] 326 | |                                          9, 10, 11, 12];
[INFO] [stdout]     | |_______________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:334:30
[INFO] [stdout]     |
[INFO] [stdout] 334 |           let a: Matrix<i64> = matrix![1, 2, 3, 4;
[INFO] [stdout]     |  ______________________________-
[INFO] [stdout] 335 | |                                      5, 6, 7, 8;
[INFO] [stdout] 336 | |                                      9, 10, 11, 12];
[INFO] [stdout]     | |___________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:348:34
[INFO] [stdout]     |
[INFO] [stdout] 348 |           let mut a: Matrix<i64> = matrix![1, 2, 3, 4;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 349 | |                                          5, 6, 7, 8;
[INFO] [stdout] 350 | |                                          9, 10, 11, 12];
[INFO] [stdout]     | |_______________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/convert.rs:356:34
[INFO] [stdout]     |
[INFO] [stdout] 356 |           let mut a: Matrix<i64> = matrix![1, 2, 3, 4;
[INFO] [stdout]     |  __________________________________-
[INFO] [stdout] 357 | |                                          5, 6, 7, 8;
[INFO] [stdout] 358 | |                                          9, 10, 11, 12];
[INFO] [stdout]     | |_______________________________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:235:17
[INFO] [stdout]     |
[INFO] [stdout] 235 |           let m = matrix![3.0, 4.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 236 | |                         1.0, 3.0];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:266:17
[INFO] [stdout]     |
[INFO] [stdout] 266 |           let m = matrix![3.0, 4.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 267 | |                         1.0, 3.0];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:273:18
[INFO] [stdout]     |
[INFO] [stdout] 273 |           let m2 = matrix![2.0, 3.0;
[INFO] [stdout]     |  __________________-
[INFO] [stdout] 274 | |                          2.0, 4.0];
[INFO] [stdout]     | |__________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:281:17
[INFO] [stdout]     |
[INFO] [stdout] 281 |         let m = matrix![3.0, 4.0];
[INFO] [stdout]     |                 ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:282:18
[INFO] [stdout]     |
[INFO] [stdout] 282 |         let m2 = matrix![1.0, 2.0, 3.0];
[INFO] [stdout]     |                  ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:297:17
[INFO] [stdout]     |
[INFO] [stdout] 297 |           let m = matrix![0.0, -2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 298 | |                         3.5, 1.0];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:312:17
[INFO] [stdout]     |
[INFO] [stdout] 312 |           let m = matrix![1.0, -2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 313 | |                         0.5, 1.0];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/norm/mod.rs:325:17
[INFO] [stdout]     |
[INFO] [stdout] 325 |           let m = matrix![1.0, -2.0;
[INFO] [stdout]     |  _________________-
[INFO] [stdout] 326 | |                         0.5, 1.0];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:47:17
[INFO] [stdout]    |
[INFO] [stdout] 47 |         let x = matrix![1];
[INFO] [stdout]    |                 ---------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:54:21
[INFO] [stdout]    |
[INFO] [stdout] 54 |               let x = matrix![3, 0;
[INFO] [stdout]    |  _____________________-
[INFO] [stdout] 55 | |                             4, 5];
[INFO] [stdout]    | |_________________________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:60:21
[INFO] [stdout]    |
[INFO] [stdout] 60 |               let x = matrix![1, 0, 0;
[INFO] [stdout]    |  _____________________-
[INFO] [stdout] 61 | |                             3, 3, 0;
[INFO] [stdout] 62 | |                             0, 4, 6];
[INFO] [stdout]    | |____________________________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:68:21
[INFO] [stdout]    |
[INFO] [stdout] 68 |               let x = matrix![1, 0;
[INFO] [stdout]    |  _____________________-
[INFO] [stdout] 69 | |                             0, 2];
[INFO] [stdout]    | |_________________________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |             let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                   ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:82:17
[INFO] [stdout]    |
[INFO] [stdout] 82 |         let x = matrix![1];
[INFO] [stdout]    |                 ---------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:89:21
[INFO] [stdout]    |
[INFO] [stdout] 89 |               let x = matrix![3, 4;
[INFO] [stdout]    |  _____________________-
[INFO] [stdout] 90 | |                             0, 5];
[INFO] [stdout]    | |_________________________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]   --> src/macros/matrix.rs:59:67
[INFO] [stdout]    |
[INFO] [stdout] 59 |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]    |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]    | 
[INFO] [stdout]   ::: src/testsupport/constraints.rs:95:21
[INFO] [stdout]    |
[INFO] [stdout] 95 |               let x = matrix![1, 3, 0;
[INFO] [stdout]    |  _____________________-
[INFO] [stdout] 96 | |                             0, 3, 4;
[INFO] [stdout] 97 | |                             0, 0, 6];
[INFO] [stdout]    | |____________________________________- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]    = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/testsupport/constraints.rs:103:21
[INFO] [stdout]     |
[INFO] [stdout] 103 |               let x = matrix![1, 0;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 104 | |                             0, 2];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/testsupport/constraints.rs:112:21
[INFO] [stdout]     |
[INFO] [stdout] 112 |               let x = matrix![1, 2;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 113 | |                             0, 3;
[INFO] [stdout] 114 | |                             0, 0];
[INFO] [stdout]     | |_________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: this method call currently resolves to `<&[T; N] as IntoIterator>::into_iter` (due to autoref coercions), but that might change in the future when `IntoIterator` impls for arrays are added.
[INFO] [stdout]    --> src/macros/matrix.rs:59:67
[INFO] [stdout]     |
[INFO] [stdout] 59  |               let data_as_flat_array: Vec<_> = data_as_nested_array.into_iter()
[INFO] [stdout]     |                                                                     ^^^^^^^^^ help: use `.iter()` instead of `.into_iter()` to avoid ambiguity: `iter`
[INFO] [stdout]     | 
[INFO] [stdout]    ::: src/testsupport/constraints.rs:119:21
[INFO] [stdout]     |
[INFO] [stdout] 119 |               let x = matrix![1, 2, 3;
[INFO] [stdout]     |  _____________________-
[INFO] [stdout] 120 | |                             0, 4, 5];
[INFO] [stdout]     | |____________________________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
[INFO] [stdout]     = note: for more information, see issue #66145 <https://github.com/rust-lang/rust/issues/66145>
[INFO] [stdout]     = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 249 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 22.42s
[INFO] running `Command { std: "docker" "inspect" "4801075f2927fce8ba830f8a101baf9a574d997692be8735bd60656dcbca52a6", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "4801075f2927fce8ba830f8a101baf9a574d997692be8735bd60656dcbca52a6", kill_on_drop: false }`
[INFO] [stdout] 4801075f2927fce8ba830f8a101baf9a574d997692be8735bd60656dcbca52a6