OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

min_const_generics diagnostics improvements

Browse Source 
2

3
This commit is contained in:
Ethan Brierley 2020-10-11 16:47:45 +01:00
parent 1661f77e7b
commit d7029cbd7e
54 changed files with 182 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -469,24 +469,17 @@ impl<'a> Resolver<'a> {
ResolutionError::ParamInNonTrivialAnonConst { name, is_type } => {
let mut err = self.session.struct_span_err(
span,
"generic parameters must not be used inside of non-trivial constant values",
);
err.span_label(
span,
&format!(
"non-trivial anonymous constants must not depend on the parameter `{}`",
name
),
"generic parameters must not be used inside const evaluations",
);
err.span_label(span, &format!("cannot perform const operation using `{}`", name));
if is_type {
err.note("type parameters are currently not permitted in anonymous constants");
err.note("type parameters may not be used in anonymous constants");
} else {
err.help(
&format!("it is currently only allowed to use either `{0}` or `{{ {0} }}` as generic constants",
name
)
);
err.help(&format!(
"const parameters may only be used as standalone arguments `{}`",
name
));
}
err

2
compiler/rustc_resolve/src/lib.rs
View File

@ -218,7 +218,7 @@ enum ResolutionError<'a> {
ParamInTyOfConstParam(Symbol),
/// constant values inside of type parameter defaults must not depend on generic parameters.
ParamInAnonConstInTyDefault(Symbol),
/// generic parameters must not be used inside of non-trivial constant values.
/// generic parameters must not be used inside const evaluations.
///
/// This error is only emitted when using `min_const_generics`.
ParamInNonTrivialAnonConst { name: Symbol, is_type: bool },

12
src/test/ui/const-generics/array-size-in-generic-struct-param.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/array-size-in-generic-struct-param.rs:9:48
|
LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]);
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/array-size-in-generic-struct-param.rs:20:15
|
LL | arr: [u8; CFG.arr_size],
| ^^^ non-trivial anonymous constants must not depend on the parameter `CFG`
| ^^^ cannot perform const operation using `CFG`
|
= help: it is currently only allowed to use either `CFG` or `{ CFG }` as generic constants
= help: const parameters may only be used as standalone arguments `CFG`
error: `Config` is forbidden as the type of a const generic parameter
--> $DIR/array-size-in-generic-struct-param.rs:18:21

4
src/test/ui/const-generics/array-size-in-generic-struct-param.rs
View File

@ -8,7 +8,7 @@
#[allow(dead_code)]
struct ArithArrayLen<const N: usize>([u32; 0 + N]);
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
#[derive(PartialEq, Eq)]
struct Config {
@ -19,7 +19,7 @@ struct B<const CFG: Config> {
//[min]~^ ERROR `Config` is forbidden
arr: [u8; CFG.arr_size],
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
}
const C: Config = Config { arr_size: 5 };

6
src/test/ui/const-generics/const-argument-if-length.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/const-argument-if-length.rs:19:24
|
LL | pad: [u8; is_zst::<T>()],
| ^ non-trivial anonymous constants must not depend on the parameter `T`
| ^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error[E0277]: the size for values of type `T` cannot be known at compilation time
--> $DIR/const-argument-if-length.rs:17:12

2
src/test/ui/const-generics/const-argument-if-length.rs
View File

@ -17,7 +17,7 @@ pub struct AtLeastByte<T: ?Sized> {
value: T,
//~^ ERROR the size for values of type `T` cannot be known at compilation time
pad: [u8; is_zst::<T>()],
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[full]~^^ ERROR evaluation of constant value failed
}

6
src/test/ui/const-generics/const_evaluatable_checked/feature-gate-const_evaluatable_checked.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/feature-gate-const_evaluatable_checked.rs:6:33
|
LL | type Arr<const N: usize> = [u8; N - 1];
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/const_evaluatable_checked/feature-gate-const_evaluatable_checked.rs
View File

@ -4,7 +4,7 @@
#![cfg_attr(min, feature(min_const_generics))]
type Arr<const N: usize> = [u8; N - 1];
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
fn test<const N: usize>() -> Arr<N> where Arr<N>: Default {
//[full]~^ ERROR constant expression depends

12
src/test/ui/const-generics/const_evaluatable_checked/simple.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/simple.rs:8:53
|
LL | fn test<const N: usize>() -> [u8; N - 1] where [u8; N - 1]: Default {
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/simple.rs:8:35
|
LL | fn test<const N: usize>() -> [u8; N - 1] where [u8; N - 1]: Default {
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to 2 previous errors

6
src/test/ui/const-generics/const_evaluatable_checked/simple_fail.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/simple_fail.rs:7:33
|
LL | type Arr<const N: usize> = [u8; N - 1];
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/const_evaluatable_checked/simple_fail.rs
View File

@ -5,7 +5,7 @@
#![allow(incomplete_features)]
type Arr<const N: usize> = [u8; N - 1]; //[full]~ ERROR evaluation of constant
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
fn test<const N: usize>() -> Arr<N> where Arr<N>: Sized {
todo!()

12
src/test/ui/const-generics/generic-function-call-in-array-length.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/generic-function-call-in-array-length.rs:9:39
|
LL | fn bar<const N: usize>() -> [u32; foo(N)] {
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/generic-function-call-in-array-length.rs:12:13
|
LL | [0; foo(N)]
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to 2 previous errors

4
src/test/ui/const-generics/generic-function-call-in-array-length.rs
View File

@ -7,10 +7,10 @@
const fn foo(n: usize) -> usize { n * 2 }
fn bar<const N: usize>() -> [u32; foo(N)] {
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[full]~^^ ERROR constant expression depends on a generic parameter
[0; foo(N)]
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
}
fn main() {}

12
src/test/ui/const-generics/generic-sum-in-array-length.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/generic-sum-in-array-length.rs:7:53
|
LL | fn foo<const A: usize, const B: usize>(bar: [usize; A + B]) {}
| ^ non-trivial anonymous constants must not depend on the parameter `A`
| ^ cannot perform const operation using `A`
|
= help: it is currently only allowed to use either `A` or `{ A }` as generic constants
= help: const parameters may only be used as standalone arguments `A`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/generic-sum-in-array-length.rs:7:57
|
LL | fn foo<const A: usize, const B: usize>(bar: [usize; A + B]) {}
| ^ non-trivial anonymous constants must not depend on the parameter `B`
| ^ cannot perform const operation using `B`
|
= help: it is currently only allowed to use either `B` or `{ B }` as generic constants
= help: const parameters may only be used as standalone arguments `B`
error: aborting due to 2 previous errors

4
src/test/ui/const-generics/generic-sum-in-array-length.rs
View File

@ -5,8 +5,8 @@
#![cfg_attr(min, feature(min_const_generics))]
fn foo<const A: usize, const B: usize>(bar: [usize; A + B]) {}
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~| ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[min]~| ERROR generic parameters must not be used inside const evaluations
//[full]~^^^ ERROR constant expression depends on a generic parameter
fn main() {}

6
src/test/ui/const-generics/intrinsics-type_name-as-const-argument.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/intrinsics-type_name-as-const-argument.rs:15:44
|
LL | T: Trait<{std::intrinsics::type_name::<T>()}>
| ^ non-trivial anonymous constants must not depend on the parameter `T`
| ^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: `&'static str` is forbidden as the type of a const generic parameter
--> $DIR/intrinsics-type_name-as-const-argument.rs:10:22

2
src/test/ui/const-generics/intrinsics-type_name-as-const-argument.rs
View File

@ -13,7 +13,7 @@ trait Trait<const S: &'static str> {}
struct Bug<T>
where
T: Trait<{std::intrinsics::type_name::<T>()}>
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[full]~^^ ERROR constant expression depends on a generic parameter
{
t: T

12
src/test/ui/const-generics/issue-61522-array-len-succ.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-61522-array-len-succ.rs:7:45
|
LL | pub struct MyArray<const COUNT: usize>([u8; COUNT + 1]);
| ^^^^^ non-trivial anonymous constants must not depend on the parameter `COUNT`
| ^^^^^ cannot perform const operation using `COUNT`
|
= help: it is currently only allowed to use either `COUNT` or `{ COUNT }` as generic constants
= help: const parameters may only be used as standalone arguments `COUNT`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-61522-array-len-succ.rs:12:30
|
LL | fn inner(&self) -> &[u8; COUNT + 1] {
| ^^^^^ non-trivial anonymous constants must not depend on the parameter `COUNT`
| ^^^^^ cannot perform const operation using `COUNT`
|
= help: it is currently only allowed to use either `COUNT` or `{ COUNT }` as generic constants
= help: const parameters may only be used as standalone arguments `COUNT`
error: aborting due to 2 previous errors

6
src/test/ui/const-generics/issue-67375.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-67375.rs:9:25
|
LL | inner: [(); { [|_: &T| {}; 0].len() }],
| ^ non-trivial anonymous constants must not depend on the parameter `T`
| ^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error[E0392]: parameter `T` is never used
--> $DIR/issue-67375.rs:7:12

2
src/test/ui/const-generics/issue-67375.rs
View File

@ -7,7 +7,7 @@
struct Bug<T> {
//~^ ERROR parameter `T` is never used
inner: [(); { [|_: &T| {}; 0].len() }],
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[full]~^^ WARN cannot use constants which depend on generic parameters in types
//[full]~^^^ WARN this was previously accepted by the compiler
}

12
src/test/ui/const-generics/issue-67945-1.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-67945-1.rs:14:16
|
LL | let x: S = MaybeUninit::uninit();
| ^ non-trivial anonymous constants must not depend on the parameter `S`
| ^ cannot perform const operation using `S`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-67945-1.rs:17:45
|
LL | let b = &*(&x as *const _ as *const S);
| ^ non-trivial anonymous constants must not depend on the parameter `S`
| ^ cannot perform const operation using `S`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error[E0392]: parameter `S` is never used
--> $DIR/issue-67945-1.rs:11:12

4
src/test/ui/const-generics/issue-67945-1.rs
View File

@ -12,10 +12,10 @@ struct Bug<S> {
//~^ ERROR parameter `S` is never used
A: [(); {
let x: S = MaybeUninit::uninit();
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[full]~^^ ERROR mismatched types
let b = &*(&x as *const _ as *const S);
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
0
}],
}

12
src/test/ui/const-generics/issue-67945-2.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-67945-2.rs:12:16
|
LL | let x: S = MaybeUninit::uninit();
| ^ non-trivial anonymous constants must not depend on the parameter `S`
| ^ cannot perform const operation using `S`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-67945-2.rs:15:45
|
LL | let b = &*(&x as *const _ as *const S);
| ^ non-trivial anonymous constants must not depend on the parameter `S`
| ^ cannot perform const operation using `S`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error[E0392]: parameter `S` is never used
--> $DIR/issue-67945-2.rs:9:12

4
src/test/ui/const-generics/issue-67945-2.rs
View File

@ -10,10 +10,10 @@ struct Bug<S> {
//~^ ERROR parameter `S` is never used
A: [(); {
let x: S = MaybeUninit::uninit();
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[full]~^^ ERROR mismatched types
let b = &*(&x as *const _ as *const S);
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
0
}],
}

6
src/test/ui/const-generics/issues/issue-61747.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-61747.rs:8:30
|
LL | fn successor() -> Const<{C + 1}> {
| ^ non-trivial anonymous constants must not depend on the parameter `C`
| ^ cannot perform const operation using `C`
|
= help: it is currently only allowed to use either `C` or `{ C }` as generic constants
= help: const parameters may only be used as standalone arguments `C`
error: aborting due to previous error

6
src/test/ui/const-generics/issues/issue-61935.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-61935.rs:10:23
|
LL | Self:FooImpl<{N==0}>
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/issues/issue-61935.rs
View File

@ -9,7 +9,7 @@ impl<const N: usize> Foo for [(); N]
where
Self:FooImpl<{N==0}>
//[full]~^ERROR constant expression depends on a generic parameter
//[min]~^^ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ERROR generic parameters must not be used inside const evaluations
{}
trait FooImpl<const IS_ZERO: bool>{}

6
src/test/ui/const-generics/issues/issue-62220.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-62220.rs:8:59
|
LL | pub type TruncatedVector<T, const N: usize> = Vector<T, { N - 1 }>;
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/issues/issue-62220.rs
View File

@ -6,7 +6,7 @@
pub struct Vector<T, const N: usize>([T; N]);
pub type TruncatedVector<T, const N: usize> = Vector<T, { N - 1 }>;
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
impl<T, const N: usize> Vector<T, { N }> {
/// Drop the last component and return the vector with one fewer dimension.

6
src/test/ui/const-generics/issues/issue-62456.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-62456.rs:7:20
|
LL | let _ = [0u64; N + 1];
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/issues/issue-62456.rs
View File

@ -6,7 +6,7 @@
fn foo<const N: usize>() {
let _ = [0u64; N + 1];
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
}
fn main() {}

12
src/test/ui/const-generics/issues/issue-64494.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-64494.rs:16:38
|
LL | impl<T: Foo> MyTrait for T where Is<{T::VAL == 5}>: True {}
| ^^^^^^ non-trivial anonymous constants must not depend on the parameter `T`
| ^^^^^^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-64494.rs:19:38
|
LL | impl<T: Foo> MyTrait for T where Is<{T::VAL == 6}>: True {}
| ^^^^^^ non-trivial anonymous constants must not depend on the parameter `T`
| ^^^^^^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error[E0119]: conflicting implementations of trait `MyTrait`:
--> $DIR/issue-64494.rs:19:1

4
src/test/ui/const-generics/issues/issue-64494.rs
View File

@ -15,10 +15,10 @@ impl True for Is<{true}> {}
impl<T: Foo> MyTrait for T where Is<{T::VAL == 5}>: True {}
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
impl<T: Foo> MyTrait for T where Is<{T::VAL == 6}>: True {}
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
//[min]~| ERROR conflicting implementations of trait `MyTrait`
fn main() {}

6
src/test/ui/const-generics/issues/issue-66205.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-66205.rs:8:14
|
LL | fact::<{ N - 1 }>();
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/issues/issue-66205.rs
View File

@ -7,7 +7,7 @@
fn fact<const N: usize>() {
fact::<{ N - 1 }>();
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
}
fn main() {}

6
src/test/ui/const-generics/issues/issue-67739.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-67739.rs:12:30
|
LL | [0u8; mem::size_of::<Self::Associated>()];
| ^^^^^^^^^^^^^^^^ non-trivial anonymous constants must not depend on the parameter `Self`
| ^^^^^^^^^^^^^^^^ cannot perform const operation using `Self`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: aborting due to previous error

2
src/test/ui/const-generics/issues/issue-67739.rs
View File

@ -11,7 +11,7 @@ pub trait Trait {
fn associated_size(&self) -> usize {
[0u8; mem::size_of::<Self::Associated>()];
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
0
}
}

6
src/test/ui/const-generics/issues/issue-68366.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-68366.rs:12:37
|
LL | impl <const N: usize> Collatz<{Some(N)}> {}
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error[E0207]: the const parameter `N` is not constrained by the impl trait, self type, or predicates
--> $DIR/issue-68366.rs:12:13

2
src/test/ui/const-generics/issues/issue-68366.rs
View File

@ -11,7 +11,7 @@ struct Collatz<const N: Option<usize>>;
impl <const N: usize> Collatz<{Some(N)}> {}
//~^ ERROR the const parameter
//[min]~^^ generic parameters must not be used inside of non-trivial constant values
//[min]~^^ generic parameters must not be used inside const evaluations
struct Foo;

12
src/test/ui/const-generics/issues/issue-68977.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-68977.rs:29:17
|
LL | PhantomU8<{(INT_BITS + FRAC_BITS + 7) / 8}>;
| ^^^^^^^^ non-trivial anonymous constants must not depend on the parameter `INT_BITS`
| ^^^^^^^^ cannot perform const operation using `INT_BITS`
|
= help: it is currently only allowed to use either `INT_BITS` or `{ INT_BITS }` as generic constants
= help: const parameters may only be used as standalone arguments `INT_BITS`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-68977.rs:29:28
|
LL | PhantomU8<{(INT_BITS + FRAC_BITS + 7) / 8}>;
| ^^^^^^^^^ non-trivial anonymous constants must not depend on the parameter `FRAC_BITS`
| ^^^^^^^^^ cannot perform const operation using `FRAC_BITS`
|
= help: it is currently only allowed to use either `FRAC_BITS` or `{ FRAC_BITS }` as generic constants
= help: const parameters may only be used as standalone arguments `FRAC_BITS`
error: aborting due to 2 previous errors

4
src/test/ui/const-generics/issues/issue-68977.rs
View File

@ -27,8 +27,8 @@ fxp_storage_impls! {
type FxpStorageHelper<const INT_BITS: u8, const FRAC_BITS: u8> =
PhantomU8<{(INT_BITS + FRAC_BITS + 7) / 8}>;
//[min]~^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~| ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^ ERROR generic parameters must not be used inside const evaluations
//[min]~| ERROR generic parameters must not be used inside const evaluations
struct Fxp<const INT_BITS: u8, const FRAC_BITS: u8>
where

24
src/test/ui/const-generics/issues/issue-72787.min.stderr
View File

@ -1,34 +1,34 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-72787.rs:11:17
|
LL | Condition<{ LHS <= RHS }>: True
| ^^^ non-trivial anonymous constants must not depend on the parameter `LHS`
| ^^^ cannot perform const operation using `LHS`
|
= help: it is currently only allowed to use either `LHS` or `{ LHS }` as generic constants
= help: const parameters may only be used as standalone arguments `LHS`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-72787.rs:11:24
|
LL | Condition<{ LHS <= RHS }>: True
| ^^^ non-trivial anonymous constants must not depend on the parameter `RHS`
| ^^^ cannot perform const operation using `RHS`
|
= help: it is currently only allowed to use either `RHS` or `{ RHS }` as generic constants
= help: const parameters may only be used as standalone arguments `RHS`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-72787.rs:26:25
|
LL | IsLessOrEqual<{ 8 - I }, { 8 - J }>: True,
| ^ non-trivial anonymous constants must not depend on the parameter `I`
| ^ cannot perform const operation using `I`
|
= help: it is currently only allowed to use either `I` or `{ I }` as generic constants
= help: const parameters may only be used as standalone arguments `I`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-72787.rs:26:36
|
LL | IsLessOrEqual<{ 8 - I }, { 8 - J }>: True,
| ^ non-trivial anonymous constants must not depend on the parameter `J`
| ^ cannot perform const operation using `J`
|
= help: it is currently only allowed to use either `J` or `{ J }` as generic constants
= help: const parameters may only be used as standalone arguments `J`
error[E0283]: type annotations needed
--> $DIR/issue-72787.rs:22:26

8
src/test/ui/const-generics/issues/issue-72787.rs
View File

@ -10,8 +10,8 @@ pub trait True {}
impl<const LHS: u32, const RHS: u32> True for IsLessOrEqual<LHS, RHS> where
Condition<{ LHS <= RHS }>: True
//[full]~^ Error constant expression depends on a generic parameter
//[min]~^^ Error generic parameters must not be used inside of non-trivial constant values
//[min]~| Error generic parameters must not be used inside of non-trivial constant values
//[min]~^^ Error generic parameters must not be used inside const evaluations
//[min]~| Error generic parameters must not be used inside const evaluations
{
}
impl True for Condition<true> {}
@ -28,8 +28,8 @@ where
//[full]~| constant expression depends on a generic parameter
//[full]~| constant expression depends on a generic parameter
//[full]~| constant expression depends on a generic parameter
//[min]~^^^^^ Error generic parameters must not be used inside of non-trivial constant values
//[min]~| Error generic parameters must not be used inside of non-trivial constant values
//[min]~^^^^^ Error generic parameters must not be used inside const evaluations
//[min]~| Error generic parameters must not be used inside const evaluations
// Condition<{ 8 - I <= 8 - J }>: True,
{
fn print() {

6
src/test/ui/const-generics/issues/issue-72819-generic-in-const-eval.min.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-72819-generic-in-const-eval.rs:9:17
|
LL | where Assert::<{N < usize::max_value() / 2}>: IsTrue,
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to previous error

2
src/test/ui/const-generics/issues/issue-72819-generic-in-const-eval.rs
View File

@ -8,7 +8,7 @@
struct Arr<const N: usize>
where Assert::<{N < usize::max_value() / 2}>: IsTrue,
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
{
}

12
src/test/ui/const-generics/issues/issue-76701-ty-param-in-const.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-76701-ty-param-in-const.rs:6:46
|
LL | fn ty_param<T>() -> [u8; std::mem::size_of::<T>()] {
| ^ non-trivial anonymous constants must not depend on the parameter `T`
| ^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/issue-76701-ty-param-in-const.rs:12:42
|
LL | fn const_param<const N: usize>() -> [u8; N + 1] {
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to 2 previous errors

4
src/test/ui/const-generics/issues/issue-76701-ty-param-in-const.rs
View File

@ -5,13 +5,13 @@
fn ty_param<T>() -> [u8; std::mem::size_of::<T>()] {
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
todo!()
}
fn const_param<const N: usize>() -> [u8; N + 1] {
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial constant values
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
todo!()
}

8
src/test/ui/const-generics/min_const_generics/complex-expression.rs
View File

@ -7,19 +7,19 @@ fn ok<const M: usize>() -> [u8; M] {
}
struct Break0<const N: usize>([u8; { N + 1 }]);
//~^ ERROR generic parameters must not be used inside of non-trivial constant values
//~^ ERROR generic parameters must not be used inside const evaluations
struct Break1<const N: usize>([u8; { { N } }]);
//~^ ERROR generic parameters must not be used inside of non-trivial constant values
//~^ ERROR generic parameters must not be used inside const evaluations
fn break2<const N: usize>() {
let _: [u8; N + 1];
//~^ ERROR generic parameters must not be used inside of non-trivial constant values
//~^ ERROR generic parameters must not be used inside const evaluations
}
fn break3<const N: usize>() {
let _ = [0; N + 1];
//~^ ERROR generic parameters must not be used inside of non-trivial constant values
//~^ ERROR generic parameters must not be used inside const evaluations
}
trait Foo {

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

@ -1,34 +1,34 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/complex-expression.rs:9:38
|
LL | struct Break0<const N: usize>([u8; { N + 1 }]);
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/complex-expression.rs:12:40
|
LL | struct Break1<const N: usize>([u8; { { N } }]);
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/complex-expression.rs:16:17
|
LL | let _: [u8; N + 1];
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/complex-expression.rs:21:17
|
LL | let _ = [0; N + 1];
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to 4 previous errors

6
src/test/ui/const-generics/min_const_generics/self-ty-in-const-1.stderr
View File

@ -1,10 +1,10 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/self-ty-in-const-1.rs:4:41
|
LL | fn t1() -> [u8; std::mem::size_of::<Self>()];
| ^^^^ non-trivial anonymous constants must not depend on the parameter `Self`
| ^^^^ cannot perform const operation using `Self`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: generic `Self` types are currently not permitted in anonymous constants
--> $DIR/self-ty-in-const-1.rs:14:41

6
src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.min.stderr
View File

@ -6,13 +6,13 @@ LL | struct Bar<T = [u8; N], const N: usize>(T);
|
= note: using type defaults and const parameters in the same parameter list is currently not permitted
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:7:44
|
LL | struct Foo<T, U = [u8; std::mem::size_of::<T>()]>(T, U);
| ^ non-trivial anonymous constants must not depend on the parameter `T`
| ^ cannot perform const operation using `T`
|
= note: type parameters are currently not permitted in anonymous constants
= note: type parameters may not be used in anonymous constants
error: constant values inside of type parameter defaults must not depend on generic parameters
--> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:12:21

2
src/test/ui/const-generics/params-in-ct-in-ty-param-lazy-norm.rs
View File

@ -6,7 +6,7 @@
struct Foo<T, U = [u8; std::mem::size_of::<T>()]>(T, U);
//[full]~^ ERROR constant values inside of type parameter defaults
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
// FIXME(const_generics:defaults): We still don't know how to we deal with type defaults.
struct Bar<T = [u8; N], const N: usize>(T);

12
src/test/ui/const-generics/wf-misc.min.stderr
View File

@ -1,18 +1,18 @@
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/wf-misc.rs:9:17
|
LL | let _: [u8; N + 1];
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: generic parameters must not be used inside of non-trivial constant values
error: generic parameters must not be used inside const evaluations
--> $DIR/wf-misc.rs:17:21
|
LL | let _: Const::<{N + 1}>;
| ^ non-trivial anonymous constants must not depend on the parameter `N`
| ^ cannot perform const operation using `N`
|
= help: it is currently only allowed to use either `N` or `{ N }` as generic constants
= help: const parameters may only be used as standalone arguments `N`
error: aborting due to 2 previous errors

4
src/test/ui/const-generics/wf-misc.rs
View File

@ -8,7 +8,7 @@
pub fn arr_len<const N: usize>() {
let _: [u8; N + 1];
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
}
struct Const<const N: usize>;
@ -16,7 +16,7 @@ struct Const<const N: usize>;
pub fn func_call<const N: usize>() {
let _: Const::<{N + 1}>;
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters must not be used inside of non-trivial
//[min]~^^ ERROR generic parameters must not be used inside const evaluations
}
fn main() {}