bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Const generic parameters aren't bounds, even if we end up erroring because of the bound that binds the parameter's type

Browse source
This commit is contained in:
Oli Scherer 2024-06-19 08:25:58 +00:00
parent 1cb75dc4a9
commit e4c9a8cf9b
19 changed files with 146 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

28
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -2776,9 +2776,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let mut this = "this bound"; let mut this = "this bound";
let mut note = None; let mut note = None;
let mut help = None; let mut help = None;
if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() {
&& let ty::ClauseKind::Trait(trait_pred) = clause match clause {
{ ty::ClauseKind::Trait(trait_pred) => {
let def_id = trait_pred.def_id(); let def_id = trait_pred.def_id();
let visible_item = if let Some(local) = def_id.as_local() { let visible_item = if let Some(local) = def_id.as_local() {
// Check for local traits being reachable. // Check for local traits being reachable.
@ -2799,7 +2799,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
.any(|param| tcx.def_span(param.def_id) == span) .any(|param| tcx.def_span(param.def_id) == span)
{ {
a = "an implicit `Sized`"; a = "an implicit `Sized`";
this = "the implicit `Sized` requirement on this type parameter"; this =
"the implicit `Sized` requirement on this type parameter";
} }
if let Some(hir::Node::TraitItem(hir::TraitItem { if let Some(hir::Node::TraitItem(hir::TraitItem {
generics, generics,
@ -2866,7 +2867,24 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
)); ));
} }
} }
}; }
ty::ClauseKind::ConstArgHasType(..) => {
let descr =
format!("required by a const generic parameter in `{item_name}`");
if span.is_visible(sm) {
let msg = format!(
"required by this const generic parameter in `{short_item_name}`"
);
multispan.push_span_label(span, msg);
err.span_note(multispan, descr);
} else {
err.span_note(tcx.def_span(item_def_id), descr);
}
return;
}
_ => (),
}
}
let descr = format!("required by {a} bound in `{item_name}`"); let descr = format!("required by {a} bound in `{item_name}`");
if span.is_visible(sm) { if span.is_visible(sm) {
let msg = format!("required by {this} in `{short_item_name}`"); let msg = format!("required by {this} in `{short_item_name}`");

8
tests/ui/const-generics/defaults/doesnt_infer.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed for `Foo<_>`
LL | let foo = Foo::foo(); LL | let foo = Foo::foo();
| ^^^ ---------- type must be known at this point | ^^^ ---------- type must be known at this point
| |
note: required by a bound in `Foo::<N>::foo` note: required by a const generic parameter in `Foo::<N>::foo`
--> $DIR/doesnt_infer.rs:5:6 --> $DIR/doesnt_infer.rs:5:6
| |
LL | impl<const N: u32> Foo<N> { LL | impl<const N: u32> Foo<N> {
| ^^^^^^^^^^^^ required by this bound in `Foo::<N>::foo` | ^^^^^^^^^^^^ required by this const generic parameter in `Foo::<N>::foo`
LL | fn foo() -> Self { LL | fn foo() -> Self {
| --- required by a bound in this associated function | --- required by a bound in this associated function
help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
@ -22,11 +22,11 @@ error[E0284]: type annotations needed for `Foo<_>`
LL | let foo = Foo::foo(); LL | let foo = Foo::foo();
| ^^^ --- type must be known at this point | ^^^ --- type must be known at this point
| |
note: required by a bound in `Foo` note: required by a const generic parameter in `Foo`
--> $DIR/doesnt_infer.rs:3:12 --> $DIR/doesnt_infer.rs:3:12
| |
LL | struct Foo<const N: u32 = 2>; LL | struct Foo<const N: u32 = 2>;
| ^^^^^^^^^^^^^^^^ required by this bound in `Foo` | ^^^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
| |
LL | let foo: Foo<N> = Foo::foo(); LL | let foo: Foo<N> = Foo::foo();

4
tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr
View file

@ -37,11 +37,11 @@ error[E0284]: type annotations needed
LL | uwu(); LL | uwu();
| ^^^ cannot infer the value of the const parameter `N` declared on the function `uwu` | ^^^ cannot infer the value of the const parameter `N` declared on the function `uwu`
| |
note: required by a bound in `uwu` note: required by a const generic parameter in `uwu`
--> $DIR/rp_impl_trait_fail.rs:16:8 --> $DIR/rp_impl_trait_fail.rs:16:8
| |
LL | fn uwu<const N: u8>() -> impl Traitor<N> { LL | fn uwu<const N: u8>() -> impl Traitor<N> {
| ^^^^^^^^^^^ required by this bound in `uwu` | ^^^^^^^^^^^ required by this const generic parameter in `uwu`
help: consider specifying the generic argument help: consider specifying the generic argument
| |
LL | uwu::<N>(); LL | uwu::<N>();

4
tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
View file

@ -4,7 +4,7 @@ error[E0284]: type annotations needed for `Mask<_, _>`
LL | let y = Mask::<_, _>::splat(false); LL | let y = Mask::<_, _>::splat(false);
| ^ -------------------------- type must be known at this point | ^ -------------------------- type must be known at this point
| |
note: required by a bound in `Mask::<T, N>::splat` note: required by a const generic parameter in `Mask::<T, N>::splat`
--> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL --> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
help: consider giving `y` an explicit type, where the value of const parameter `N` is specified help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
| |
@ -17,7 +17,7 @@ error[E0284]: type annotations needed for `Mask<_, _>`
LL | let y = Mask::<_, _>::splat(false); LL | let y = Mask::<_, _>::splat(false);
| ^ ------------ type must be known at this point | ^ ------------ type must be known at this point
| |
note: required by a bound in `Mask` note: required by a const generic parameter in `Mask`
--> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL --> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
help: consider giving `y` an explicit type, where the value of const parameter `N` is specified help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
| |

8
tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr
View file

@ -24,11 +24,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
LL | let mut array = ArrayHolder::new(); LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^ ------------------ type must be known at this point | ^^^^^^^^^ ------------------ type must be known at this point
| |
note: required by a bound in `ArrayHolder::<X>::new` note: required by a const generic parameter in `ArrayHolder::<X>::new`
--> $DIR/issue-62504.rs:16:6 --> $DIR/issue-62504.rs:16:6
| |
LL | impl<const X: usize> ArrayHolder<X> { LL | impl<const X: usize> ArrayHolder<X> {
| ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder::<X>::new` | ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
LL | pub const fn new() -> Self { LL | pub const fn new() -> Self {
| --- required by a bound in this associated function | --- required by a bound in this associated function
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
@ -42,11 +42,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
LL | let mut array = ArrayHolder::new(); LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^ ----------- type must be known at this point | ^^^^^^^^^ ----------- type must be known at this point
| |
note: required by a bound in `ArrayHolder` note: required by a const generic parameter in `ArrayHolder`
--> $DIR/issue-62504.rs:14:20 --> $DIR/issue-62504.rs:14:20
| |
LL | struct ArrayHolder<const X: usize>([u32; X]); LL | struct ArrayHolder<const X: usize>([u32; X]);
| ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder` | ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
| |
LL | let mut array: ArrayHolder<X> = ArrayHolder::new(); LL | let mut array: ArrayHolder<X> = ArrayHolder::new();

8
tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
View file

@ -28,11 +28,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
LL | let mut array = ArrayHolder::new(); LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^ ------------------ type must be known at this point | ^^^^^^^^^ ------------------ type must be known at this point
| |
note: required by a bound in `ArrayHolder::<X>::new` note: required by a const generic parameter in `ArrayHolder::<X>::new`
--> $DIR/issue-62504.rs:16:6 --> $DIR/issue-62504.rs:16:6
| |
LL | impl<const X: usize> ArrayHolder<X> { LL | impl<const X: usize> ArrayHolder<X> {
| ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder::<X>::new` | ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
LL | pub const fn new() -> Self { LL | pub const fn new() -> Self {
| --- required by a bound in this associated function | --- required by a bound in this associated function
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
@ -46,11 +46,11 @@ error[E0284]: type annotations needed for `ArrayHolder<_>`
LL | let mut array = ArrayHolder::new(); LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^ ----------- type must be known at this point | ^^^^^^^^^ ----------- type must be known at this point
| |
note: required by a bound in `ArrayHolder` note: required by a const generic parameter in `ArrayHolder`
--> $DIR/issue-62504.rs:14:20 --> $DIR/issue-62504.rs:14:20
| |
LL | struct ArrayHolder<const X: usize>([u32; X]); LL | struct ArrayHolder<const X: usize>([u32; X]);
| ^^^^^^^^^^^^^^ required by this bound in `ArrayHolder` | ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
| |
LL | let mut array: ArrayHolder<X> = ArrayHolder::new(); LL | let mut array: ArrayHolder<X> = ArrayHolder::new();

4
tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | use_dyn(&()); LL | use_dyn(&());
| ^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `use_dyn` | ^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `use_dyn`
| |
note: required by a bound in `use_dyn` note: required by a const generic parameter in `use_dyn`
--> $DIR/object-safety-ok-infer-err.rs:14:12 --> $DIR/object-safety-ok-infer-err.rs:14:12
| |
LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized { LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
| ^^^^^^^^^^^^^^ required by this bound in `use_dyn` | ^^^^^^^^^^^^^^ required by this const generic parameter in `use_dyn`
help: consider specifying the generic argument help: consider specifying the generic argument
| |
LL | use_dyn::<N>(&()); LL | use_dyn::<N>(&());

4
tests/ui/const-generics/infer/cannot-infer-const-args.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | foo(); LL | foo();
| ^^^ cannot infer the value of the const parameter `X` declared on the function `foo` | ^^^ cannot infer the value of the const parameter `X` declared on the function `foo`
| |
note: required by a bound in `foo` note: required by a const generic parameter in `foo`
--> $DIR/cannot-infer-const-args.rs:1:8 --> $DIR/cannot-infer-const-args.rs:1:8
| |
LL | fn foo<const X: usize>() -> usize { LL | fn foo<const X: usize>() -> usize {
| ^^^^^^^^^^^^^^ required by this bound in `foo` | ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
help: consider specifying the generic argument help: consider specifying the generic argument
| |
LL | foo::<X>(); LL | foo::<X>();

4
tests/ui/const-generics/infer/issue-77092.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | println!("{:?}", take_array_from_mut(&mut arr, i)); LL | println!("{:?}", take_array_from_mut(&mut arr, i));
| ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut` | ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut`
| |
note: required by a bound in `take_array_from_mut` note: required by a const generic parameter in `take_array_from_mut`
--> $DIR/issue-77092.rs:3:27 --> $DIR/issue-77092.rs:3:27
| |
LL | fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] { LL | fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
| ^^^^^^^^^^^^^^ required by this bound in `take_array_from_mut` | ^^^^^^^^^^^^^^ required by this const generic parameter in `take_array_from_mut`
help: consider specifying the generic arguments help: consider specifying the generic arguments
| |
LL | println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i)); LL | println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));

4
tests/ui/const-generics/infer/method-chain.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | Foo.bar().bar().bar().bar().baz(); LL | Foo.bar().bar().bar().bar().baz();
| ^^^ cannot infer the value of the const parameter `N` declared on the method `baz` | ^^^ cannot infer the value of the const parameter `N` declared on the method `baz`
| |
note: required by a bound in `Foo::baz` note: required by a const generic parameter in `Foo::baz`
--> $DIR/method-chain.rs:8:12 --> $DIR/method-chain.rs:8:12
| |
LL | fn baz<const N: usize>(self) -> Foo { LL | fn baz<const N: usize>(self) -> Foo {
| ^^^^^^^^^^^^^^ required by this bound in `Foo::baz` | ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::baz`
help: consider specifying the generic argument help: consider specifying the generic argument
| |
LL | Foo.bar().bar().bar().bar().baz::<N>(); LL | Foo.bar().bar().bar().bar().baz::<N>();

4
tests/ui/const-generics/infer/one-param-uninferred.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | let _: [u8; 17] = foo(); LL | let _: [u8; 17] = foo();
| ^^^ cannot infer the value of the const parameter `M` declared on the function `foo` | ^^^ cannot infer the value of the const parameter `M` declared on the function `foo`
| |
note: required by a bound in `foo` note: required by a const generic parameter in `foo`
--> $DIR/one-param-uninferred.rs:2:24 --> $DIR/one-param-uninferred.rs:2:24
| |
LL | fn foo<const N: usize, const M: usize>() -> [u8; N] { LL | fn foo<const N: usize, const M: usize>() -> [u8; N] {
| ^^^^^^^^^^^^^^ required by this bound in `foo` | ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
help: consider specifying the generic arguments help: consider specifying the generic arguments
| |
LL | let _: [u8; 17] = foo::<17, M>(); LL | let _: [u8; 17] = foo::<17, M>();

8
tests/ui/const-generics/infer/uninferred-consts.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | Foo.foo(); LL | Foo.foo();
| ^^^ cannot infer the value of the const parameter `A` declared on the method `foo` | ^^^ cannot infer the value of the const parameter `A` declared on the method `foo`
| |
note: required by a bound in `Foo::foo` note: required by a const generic parameter in `Foo::foo`
--> $DIR/uninferred-consts.rs:6:12 --> $DIR/uninferred-consts.rs:6:12
| |
LL | fn foo<const A: usize, const B: usize>(self) {} LL | fn foo<const A: usize, const B: usize>(self) {}
| ^^^^^^^^^^^^^^ required by this bound in `Foo::foo` | ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::foo`
help: consider specifying the generic arguments help: consider specifying the generic arguments
| |
LL | Foo.foo::<A, B>(); LL | Foo.foo::<A, B>();
@ -20,11 +20,11 @@ error[E0284]: type annotations needed
LL | Foo.foo(); LL | Foo.foo();
| ^^^ cannot infer the value of the const parameter `B` declared on the method `foo` | ^^^ cannot infer the value of the const parameter `B` declared on the method `foo`
| |
note: required by a bound in `Foo::foo` note: required by a const generic parameter in `Foo::foo`
--> $DIR/uninferred-consts.rs:6:28 --> $DIR/uninferred-consts.rs:6:28
| |
LL | fn foo<const A: usize, const B: usize>(self) {} LL | fn foo<const A: usize, const B: usize>(self) {}
| ^^^^^^^^^^^^^^ required by this bound in `Foo::foo` | ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::foo`
help: consider specifying the generic arguments help: consider specifying the generic arguments
| |
LL | Foo.foo::<A, B>(); LL | Foo.foo::<A, B>();

4
tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | generics_of_parent_impl_trait::foo([()]); LL | generics_of_parent_impl_trait::foo([()]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo`
| |
note: required by a bound in `foo` note: required by a const generic parameter in `foo`
--> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:12 --> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:12
| |
LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) { LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) {
| ^^^^^^^^^^^^^^ required by this bound in `foo` | ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
error: aborting due to 1 previous error error: aborting due to 1 previous error

4
tests/ui/const-generics/type_mismatch.stderr
View file

@ -4,11 +4,11 @@ error: the constant `N` is not of type `u8`
LL | bar::<N>() LL | bar::<N>()
| ^ expected `u8`, found `usize` | ^ expected `u8`, found `usize`
| |
note: required by a bound in `bar` note: required by a const generic parameter in `bar`
--> $DIR/type_mismatch.rs:6:8 --> $DIR/type_mismatch.rs:6:8
| |
LL | fn bar<const N: u8>() -> [u8; N] {} LL | fn bar<const N: u8>() -> [u8; N] {}
| ^^^^^^^^^^^ required by this bound in `bar` | ^^^^^^^^^^^ required by this const generic parameter in `bar`
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:6:26 --> $DIR/type_mismatch.rs:6:26

4
tests/ui/const-generics/unify_with_nested_expr.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | bar(); LL | bar();
| ^^^ cannot infer the value of the const parameter `N` declared on the function `bar` | ^^^ cannot infer the value of the const parameter `N` declared on the function `bar`
| |
note: required by a bound in `bar` note: required by a const generic parameter in `bar`
--> $DIR/unify_with_nested_expr.rs:12:8 --> $DIR/unify_with_nested_expr.rs:12:8
| |
LL | fn bar<const N: usize>() LL | fn bar<const N: usize>()
| ^^^^^^^^^^^^^^ required by this bound in `bar` | ^^^^^^^^^^^^^^ required by this const generic parameter in `bar`
help: consider specifying the generic argument help: consider specifying the generic argument
| |
LL | bar::<N>(); LL | bar::<N>();

4
tests/ui/inference/issue-83606.stderr
View file

@ -4,11 +4,11 @@ error[E0284]: type annotations needed for `[usize; _]`
LL | let _ = foo("foo"); LL | let _ = foo("foo");
| ^ ---------- type must be known at this point | ^ ---------- type must be known at this point
| |
note: required by a bound in `foo` note: required by a const generic parameter in `foo`
--> $DIR/issue-83606.rs:3:8 --> $DIR/issue-83606.rs:3:8
| |
LL | fn foo<const N: usize>(_: impl std::fmt::Display) -> [usize; N] { LL | fn foo<const N: usize>(_: impl std::fmt::Display) -> [usize; N] {
| ^^^^^^^^^^^^^^ required by this bound in `foo` | ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
help: consider giving this pattern a type, where the value of const parameter `N` is specified help: consider giving this pattern a type, where the value of const parameter `N` is specified
| |
LL | let _: [usize; N] = foo("foo"); LL | let _: [usize; N] = foo("foo");

4
tests/ui/issues/issue-98299.stderr
View file

@ -6,11 +6,11 @@ LL | SmallCString::try_from(p).map(|cstr| cstr);
| | | |
| type must be known at this point | type must be known at this point
| |
note: required by a bound in `SmallCString` note: required by a const generic parameter in `SmallCString`
--> $DIR/issue-98299.rs:10:25 --> $DIR/issue-98299.rs:10:25
| |
LL | pub struct SmallCString<const N: usize> {} LL | pub struct SmallCString<const N: usize> {}
| ^^^^^^^^^^^^^^ required by this bound in `SmallCString` | ^^^^^^^^^^^^^^ required by this const generic parameter in `SmallCString`
help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
| |
LL | SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr); LL | SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);

4
tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
View file

@ -14,11 +14,11 @@ LL | impl<const C: usize> Wrapper<C> {}
| |
= help: consider constraining the associated type `<i32 as Trait>::Type` to `usize` = help: consider constraining the associated type `<i32 as Trait>::Type` to `usize`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `Wrapper` note: required by a const generic parameter in `Wrapper`
--> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:12:16 --> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:12:16
| |
LL | struct Wrapper<const C: <i32 as Trait>::Type> {} LL | struct Wrapper<const C: <i32 as Trait>::Type> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Wrapper` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Wrapper`
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30 --> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30

2
tests/ui/transmutability/issue-101739-1.stderr
View file

@ -10,7 +10,7 @@ error: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
| |
note: required by a bound in `BikeshedIntrinsicFrom` note: required by a const generic parameter in `BikeshedIntrinsicFrom`
--> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
error[E0308]: mismatched types error[E0308]: mismatched types