src/test/ui/const-generics/min_const_generics/complex-expression.stderr

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:9:38
   |
LL | struct Break0<const N: usize>([u8; { N + 1 }]);
   |                                      ^ cannot perform const operation using `N`
   |
   = help: const parameters may only be used as standalone arguments, i.e. `N`
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:12:40
   |
LL | struct Break1<const N: usize>([u8; { { N } }]);
   |                                        ^ cannot perform const operation using `N`
   |
   = help: const parameters may only be used as standalone arguments, i.e. `N`
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:16:17
   |
LL |     let _: [u8; N + 1];
   |                 ^ cannot perform const operation using `N`
   |
   = help: const parameters may only be used as standalone arguments, i.e. `N`
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:21:17
   |
LL |     let _ = [0; N + 1];
   |                 ^ cannot perform const operation using `N`
   |
   = help: const parameters may only be used as standalone arguments, i.e. `N`
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:25:45
   |
LL | struct BreakTy0<T>(T, [u8; { size_of::<*mut T>() }]);
   |                                             ^ cannot perform const operation using `T`
   |
   = note: type parameters may not be used in const expressions
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:28:47
   |
LL | struct BreakTy1<T>(T, [u8; { { size_of::<*mut T>() } }]);
   |                                               ^ cannot perform const operation using `T`
   |
   = note: type parameters may not be used in const expressions
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

error: generic parameters may not be used in const operations
  --> $DIR/complex-expression.rs:32:32
   |
LL |     let _: [u8; size_of::<*mut T>() + 1];
   |                                ^ cannot perform const operation using `T`
   |
   = note: type parameters may not be used in const expressions
   = help: use `#![feature(const_generics)]` and `#![feature(const_evaluatable_checked)]` to allow generic const expressions

warning: cannot use constants which depend on generic parameters in types
  --> $DIR/complex-expression.rs:37:17
   |
LL |     let _ = [0; size_of::<*mut T>() + 1];
   |                 ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(const_evaluatable_unchecked)]` on by default
   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
   = note: for more information, see issue #76200 <https://github.com/rust-lang/rust/issues/76200>

error: aborting due to 7 previous errors; 1 warning emitted