Doesn't compile with latest nightly

[bjorn3]

$ rustc -vV
rustc 1.56.0-nightly (29ef6cf16 2021-08-31)
binary: rustc
commit-hash: 29ef6cf1637aa8317f8911f93f14e18d404c1b0e
commit-date: 2021-08-31
host: x86_64-unknown-linux-gnu
release: 1.56.0-nightly
LLVM version: 13.0.0
$ cargo test
   Compiling rand_core v0.5.1
   Compiling ppv-lite86 v0.2.10
   Compiling byteorder v1.4.3
   Compiling bitflags v1.3.2
   Compiling cfg-if v0.1.10
   Compiling scoped-tls v1.0.0
   Compiling core_simd v0.1.0 (/home/bjorn/Projects/cg_clif2/portable-simd/crates/core_simd)
   Compiling wasm-bindgen v0.2.76
   Compiling rand_xorshift v0.2.0
error[E0557]: feature has been removed
 --> crates/core_simd/src/lib.rs:4:5
  |
4 |     const_evaluatable_checked,
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^ feature has been removed
  |
  = note: renamed to `generic_const_exprs`

error[E0557]: feature has been removed
 --> crates/core_simd/src/lib.rs:6:5
  |
6 |     const_generics,
  |     ^^^^^^^^^^^^^^ feature has been removed
  |
  = note: removed in favor of `#![feature(adt_const_params]` and `#![feature(generic_const_exprs)]`

   Compiling num-traits v0.2.14
   Compiling syn v1.0.75
error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
23 | impl_to_bytes! { u8, 1 }
   | ------------------------ in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
23 | impl_to_bytes! { u8, 1 }
   | ------------------------ in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
23 | impl_to_bytes! { u8, 1 }
   | ------------------------ in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
24 | impl_to_bytes! { u16, 2 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
24 | impl_to_bytes! { u16, 2 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
24 | impl_to_bytes! { u16, 2 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
25 | impl_to_bytes! { u32, 4 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
25 | impl_to_bytes! { u32, 4 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
25 | impl_to_bytes! { u32, 4 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
26 | impl_to_bytes! { u64, 8 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
26 | impl_to_bytes! { u64, 8 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
26 | impl_to_bytes! { u64, 8 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
30 | impl_to_bytes! { usize, 8 }
   | --------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
30 | impl_to_bytes! { usize, 8 }
   | --------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
30 | impl_to_bytes! { usize, 8 }
   | --------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
32 | impl_to_bytes! { i8, 1 }
   | ------------------------ in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
32 | impl_to_bytes! { i8, 1 }
   | ------------------------ in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
32 | impl_to_bytes! { i8, 1 }
   | ------------------------ in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
33 | impl_to_bytes! { i16, 2 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
33 | impl_to_bytes! { i16, 2 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
33 | impl_to_bytes! { i16, 2 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
34 | impl_to_bytes! { i32, 4 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
34 | impl_to_bytes! { i32, 4 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
34 | impl_to_bytes! { i32, 4 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
35 | impl_to_bytes! { i64, 8 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
35 | impl_to_bytes! { i64, 8 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
35 | impl_to_bytes! { i64, 8 }
   | ------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:6:41
   |
6  |             crate::LaneCount<{{ $size * LANES }}>: crate::SupportedLaneCount,
   |                                         ^^^^^ cannot perform const operation using `LANES`
...
39 | impl_to_bytes! { isize, 8 }
   | --------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:10:68
   |
10 |             pub fn to_ne_bytes(self) -> crate::Simd<u8, {{ $size * LANES }}> {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
39 | impl_to_bytes! { isize, 8 }
   | --------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error: generic parameters may not be used in const operations
  --> crates/core_simd/src/to_bytes.rs:16:68
   |
16 |             pub fn from_ne_bytes(bytes: crate::Simd<u8, {{ $size * LANES }}>) -> Self {
   |                                                                    ^^^^^ cannot perform const operation using `LANES`
...
39 | impl_to_bytes! { isize, 8 }
   | --------------------------- in this macro invocation
   |
   = help: const parameters may only be used as standalone arguments, i.e. `LANES`
   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

   Compiling wasm-bindgen-test-macro v0.3.26
error: generic parameters may not be used in const operations
   --> crates/core_simd/src/masks/full_masks.rs:105:49
    |
105 |     pub fn to_bitmask(self) -> [u8; LaneCount::<LANES>::BITMASK_LEN] {
    |                                                 ^^^^^ cannot perform const operation using `LANES`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `LANES`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions

error: generic parameters may not be used in const operations
   --> crates/core_simd/src/masks/full_masks.rs:114:47
    |
114 |             let mut bitmask: [u8; LaneCount::<LANES>::BITMASK_LEN] =
    |                                               ^^^^^ cannot perform const operation using `LANES`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `LANES`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions

error: generic parameters may not be used in const operations
   --> crates/core_simd/src/masks/full_masks.rs:131:55
    |
131 |     pub fn from_bitmask(mut bitmask: [u8; LaneCount::<LANES>::BITMASK_LEN]) -> Self {
    |                                                       ^^^^^ cannot perform const operation using `LANES`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `LANES`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions

error: generic parameters may not be used in const operations
   --> crates/core_simd/src/masks.rs:181:49
    |
181 |     pub fn to_bitmask(self) -> [u8; LaneCount::<LANES>::BITMASK_LEN] {
    |                                                 ^^^^^ cannot perform const operation using `LANES`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `LANES`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions

error: generic parameters may not be used in const operations
   --> crates/core_simd/src/masks.rs:186:51
    |
186 |     pub fn from_bitmask(bitmask: [u8; LaneCount::<LANES>::BITMASK_LEN]) -> Self {
    |                                                   ^^^^^ cannot perform const operation using `LANES`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `LANES`
    = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions

error[E0460]: found possibly newer version of crate `std` which `proc_macro2` depends on
   --> /home/bjorn/.cargo/registry/src/git.colasdn.top-1ecc6299db9ec823/syn-1.0.75/src/lib.rs:306:1
    |
306 | extern crate proc_macro2;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: perhaps that crate needs to be recompiled?
    = note: the following crate versions were found:
            crate `std`: /home/bjorn/.rustup/toolchains/nightly-2021-09-01-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd-d31eae41cd792517.rlib
            crate `std`: /home/bjorn/.rustup/toolchains/nightly-2021-09-01-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd-d31eae41cd792517.so
            crate `proc_macro2`: /home/bjorn/Projects/cg_clif2/portable-simd/target/debug/deps/libproc_macro2-fc6b92fa46147edf.rmeta

error: could not compile `syn` due to previous error
warning: build failed, waiting for other jobs to finish...
error[E0460]: found possibly newer version of crate `std` which `proc_macro2` depends on
 --> /home/bjorn/.cargo/registry/src/git.colasdn.top-1ecc6299db9ec823/wasm-bindgen-test-macro-0.3.26/src/lib.rs:6:5
  |
6 | use proc_macro2::*;
  |     ^^^^^^^^^^^
  |
  = note: perhaps that crate needs to be recompiled?
  = note: the following crate versions were found:
          crate `std`: /home/bjorn/.rustup/toolchains/nightly-2021-09-01-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd-d31eae41cd792517.rlib
          crate `std`: /home/bjorn/.rustup/toolchains/nightly-2021-09-01-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-unknown-linux-gnu/lib/libstd-d31eae41cd792517.so
          crate `proc_macro2`: /home/bjorn/Projects/cg_clif2/portable-simd/target/debug/deps/libproc_macro2-fc6b92fa46147edf.rlib

error[E0747]: unresolved item provided when a constant was expected
   --> crates/core_simd/src/masks/full_masks.rs:105:49
    |
105 |     pub fn to_bitmask(self) -> [u8; LaneCount::<LANES>::BITMASK_LEN] {
    |                                                 ^^^^^
    |
help: if this generic argument was intended as a const parameter, surround it with braces
    |
105 |     pub fn to_bitmask(self) -> [u8; LaneCount::<{ LANES }>::BITMASK_LEN] {
    |                                                 +       +

error[E0747]: unresolved item provided when a constant was expected
   --> crates/core_simd/src/masks/full_masks.rs:131:55
    |
131 |     pub fn from_bitmask(mut bitmask: [u8; LaneCount::<LANES>::BITMASK_LEN]) -> Self {
    |                                                       ^^^^^
    |
help: if this generic argument was intended as a const parameter, surround it with braces
    |
131 |     pub fn from_bitmask(mut bitmask: [u8; LaneCount::<{ LANES }>::BITMASK_LEN]) -> Self {
    |                                                       +       +

error[E0747]: unresolved item provided when a constant was expected
   --> crates/core_simd/src/masks.rs:181:49
    |
181 |     pub fn to_bitmask(self) -> [u8; LaneCount::<LANES>::BITMASK_LEN] {
    |                                                 ^^^^^
    |
help: if this generic argument was intended as a const parameter, surround it with braces
    |
181 |     pub fn to_bitmask(self) -> [u8; LaneCount::<{ LANES }>::BITMASK_LEN] {
    |                                                 +       +

error[E0747]: unresolved item provided when a constant was expected
   --> crates/core_simd/src/masks.rs:186:51
    |
186 |     pub fn from_bitmask(bitmask: [u8; LaneCount::<LANES>::BITMASK_LEN]) -> Self {
    |                                                   ^^^^^
    |
help: if this generic argument was intended as a const parameter, surround it with braces
    |
186 |     pub fn from_bitmask(bitmask: [u8; LaneCount::<{ LANES }>::BITMASK_LEN]) -> Self {
    |                                                   +       +

error: `[u32; 2]` is forbidden as the type of a const generic parameter
   --> crates/core_simd/src/permute.rs:26:39
    |
26  |             pub fn shuffle<const IDX: [u32; $n]>(self, second: Self) -> Self {
    |                                       ^^^^^^^^^
...
144 | impl_shuffle_lane! { simd_shuffle2, 2 }
    | --------------------------------------- in this macro invocation
    |
    = note: the only supported types are integers, `bool` and `char`
    = help: more complex types are supported with `#![feature(adt_const_params)]`
    = note: this error originates in the macro `impl_shuffle_lane` (in Nightly builds, run with -Z macro-backtrace for more info)

error: `[u32; 4]` is forbidden as the type of a const generic parameter
   --> crates/core_simd/src/permute.rs:26:39
    |
26  |             pub fn shuffle<const IDX: [u32; $n]>(self, second: Self) -> Self {
    |                                       ^^^^^^^^^
...
145 | impl_shuffle_lane! { simd_shuffle4, 4 }
    | --------------------------------------- in this macro invocation
    |
    = note: the only supported types are integers, `bool` and `char`
    = help: more complex types are supported with `#![feature(adt_const_params)]`
    = note: this error originates in the macro `impl_shuffle_lane` (in Nightly builds, run with -Z macro-backtrace for more info)

error: `[u32; 8]` is forbidden as the type of a const generic parameter
   --> crates/core_simd/src/permute.rs:26:39
    |
26  |             pub fn shuffle<const IDX: [u32; $n]>(self, second: Self) -> Self {
    |                                       ^^^^^^^^^
...
146 | impl_shuffle_lane! { simd_shuffle8, 8 }
    | --------------------------------------- in this macro invocation
    |
    = note: the only supported types are integers, `bool` and `char`
    = help: more complex types are supported with `#![feature(adt_const_params)]`
    = note: this error originates in the macro `impl_shuffle_lane` (in Nightly builds, run with -Z macro-backtrace for more info)

error: `[u32; 16]` is forbidden as the type of a const generic parameter
   --> crates/core_simd/src/permute.rs:26:39
    |
26  |             pub fn shuffle<const IDX: [u32; $n]>(self, second: Self) -> Self {
    |                                       ^^^^^^^^^
...
147 | impl_shuffle_lane! { simd_shuffle16, 16 }
    | ----------------------------------------- in this macro invocation
    |
    = note: the only supported types are integers, `bool` and `char`
    = help: more complex types are supported with `#![feature(adt_const_params)]`
    = note: this error originates in the macro `impl_shuffle_lane` (in Nightly builds, run with -Z macro-backtrace for more info)

error: `[u32; 32]` is forbidden as the type of a const generic parameter
   --> crates/core_simd/src/permute.rs:26:39
    |
26  |             pub fn shuffle<const IDX: [u32; $n]>(self, second: Self) -> Self {
    |                                       ^^^^^^^^^
...
148 | impl_shuffle_lane! { simd_shuffle32, 32 }
    | ----------------------------------------- in this macro invocation
    |
    = note: the only supported types are integers, `bool` and `char`
    = help: more complex types are supported with `#![feature(adt_const_params)]`
    = note: this error originates in the macro `impl_shuffle_lane` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
23 | impl_to_bytes! { u8, 1 }
   | ------------------------ in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
24 | impl_to_bytes! { u16, 2 }
   | ------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
25 | impl_to_bytes! { u32, 4 }
   | ------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
26 | impl_to_bytes! { u64, 8 }
   | ------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
30 | impl_to_bytes! { usize, 8 }
   | --------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
32 | impl_to_bytes! { i8, 1 }
   | ------------------------ in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
33 | impl_to_bytes! { i16, 2 }
   | ------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
34 | impl_to_bytes! { i32, 4 }
   | ------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
35 | impl_to_bytes! { i64, 8 }
   | ------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0283]: type annotations needed
  --> crates/core_simd/src/to_bytes.rs:5:38
   |
5  |             crate::LaneCount<LANES>: crate::SupportedLaneCount,
   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type for struct `lane_count::LaneCount<LANES>`
...
39 | impl_to_bytes! { isize, 8 }
   | --------------------------- in this macro invocation
   |
   = note: cannot satisfy `lane_count::LaneCount<LANES>: lane_count::SupportedLaneCount`
note: required by a bound in `lane_count::SupportedLaneCount`
  --> crates/core_simd/src/lane_count.rs:15:1
   |
15 | pub trait SupportedLaneCount: Sealed {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `lane_count::SupportedLaneCount`
   = note: this error originates in the macro `impl_to_bytes` (in Nightly builds, run with -Z macro-backtrace for more info)

Some errors have detailed explanations: E0283, E0557, E0747.
For more information about an error, try `rustc --explain E0283`.
error: build failed

[rana]

Use rustup default nightly-2021-08-28 until fixed.