mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
147e850691
rust/tests/ui/const-generics/transmute-fail.stderr

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

53 lines
2.2 KiB
Plaintext
Raw Normal View History

Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
Add feature gate
2023-04-04 03:41:44 -05:00
--> $DIR/transmute-fail.rs:7:5
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
|
Add feature gate
2023-04-04 03:41:44 -05:00
= note: source type: `[[u32; H+1]; W]` (generic size [const expr])
= note: target type: `[[u32; W+1]; H]` (generic size [const expr])
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
Add feature gate
2023-04-04 03:41:44 -05:00
--> $DIR/transmute-fail.rs:16:5
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `[[u32; H]; W]` (this type does not have a fixed size)
= note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
error[E0308]: mismatched types
Add feature gate
2023-04-04 03:41:44 -05:00
--> $DIR/transmute-fail.rs:12:53
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
|
LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
| ^ expected `usize`, found `bool`
error[E0308]: mismatched types
Add feature gate
2023-04-04 03:41:44 -05:00
--> $DIR/transmute-fail.rs:12:67
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
|
LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
| ^ expected `usize`, found `bool`
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
Add feature gate
2023-04-04 03:41:44 -05:00
--> $DIR/transmute-fail.rs:23:5
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
|
Add feature gate
2023-04-04 03:41:44 -05:00
= note: source type: `[[u32; H]; W]` (generic size [const expr])
= note: target type: `[u32; W * H * H]` (generic size [const expr])
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
Add feature gate
2023-04-04 03:41:44 -05:00
--> $DIR/transmute-fail.rs:30:5
Add ability to transmute with generic consts Previously if the expression contained generic consts and did not have a directly equivalent type, transmuting the type in this way was forbidden, despite the two sizes being identical. Instead, we should be able to lazily tell if the two consts are identical, and if so allow them to be transmuted.
2022-12-29 03:45:19 -06:00
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[[u32; 8888888]; 9999999]; 777777777]` are too big for the current architecture)
= note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type `[[[u32; 9999999]; 777777777]; 8888888]` are too big for the current architecture)
error: aborting due to 6 previous errors
Some errors have detailed explanations: E0308, E0512.
For more information about an error, try `rustc --explain E0308`.
Reference in New Issue Copy Permalink