rust/tests/ui/const-generics/transmute-fail.stderr

error: the constant `W` is not of type `usize`
  --> $DIR/transmute-fail.rs:12:42
   |
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
  --> $DIR/transmute-fail.rs:7:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[u32; H + 1]; W]` (size can vary because of [u32; H + 1])
   = note: target type: `[[u32; W + 1]; H]` (size can vary because of [u32; W + 1])

error: the constant `W` is not of type `usize`
  --> $DIR/transmute-fail.rs:17:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:24:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
   = note: target type: `[u32; W * H * H]` (this type does not have a fixed size)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:31:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[u32; 8888888]; 9999999]` are too big for the current architecture)
   = note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:38:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
   = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:49:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
   = note: target type: `[u32; W * H]` (this type does not have a fixed size)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:56:9
   |
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[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:65:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
   = note: target type: `[u32; D * W * H]` (this type does not have a fixed size)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:74:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
   = note: target type: `[[u32; D * W]; H]` (size can vary because of [u32; D * W])

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:81:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[u16; L]` (this type does not have a fixed size)
   = note: target type: `[u8; L * 2]` (this type does not have a fixed size)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:88:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[u8; L * 2]` (this type does not have a fixed size)
   = note: target type: `[u16; L]` (this type does not have a fixed size)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:95:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[u8; L]` (this type does not have a fixed size)
   = note: target type: `[[u8; 1]; L]` (this type does not have a fixed size)

error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
  --> $DIR/transmute-fail.rs:104:9
   |
LL |         std::mem::transmute(v)
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = note: source type: `[[u32; 2 * H]; W + W]` (size can vary because of [u32; 2 * H])
   = note: target type: `[[u32; W + W]; 2 * H]` (size can vary because of [u32; W + W])

error[E0308]: mismatched types
  --> $DIR/transmute-fail.rs:12:53
   |
LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
   |                                                     ^ expected `usize`, found `bool`

error[E0308]: mismatched types
  --> $DIR/transmute-fail.rs:12:67
   |
LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
   |                                                                   ^ expected `usize`, found `bool`

error: aborting due to 16 previous errors

Some errors have detailed explanations: E0308, E0512.
For more information about an error, try `rustc --explain E0308`.
Add `ConstArgKind::Path` and make `ConstArg` its own HIR node This is a very large commit since a lot needs to be changed in order to make the tests pass. The salient changes are: - `ConstArgKind` gets a new `Path` variant, and all const params are now represented using it. Non-param paths still use `ConstArgKind::Anon` to prevent this change from getting too large, but they will soon use the `Path` variant too. - `ConstArg` gets a distinct `hir_id` field and its own variant in `hir::Node`. This affected many parts of the compiler that expected the parent of an `AnonConst` to be the containing context (e.g., an array repeat expression). They have been changed to check the "grandparent" where necessary. - Some `ast::AnonConst`s now have their `DefId`s created in rustc_ast_lowering rather than `DefCollector`. This is because in some cases they will end up becoming a `ConstArgKind::Path` instead, which has no `DefId`. We have to solve this in a hacky way where we guess whether the `AnonConst` could end up as a path const since we can't know for sure until after name resolution (`N` could refer to a free const or a nullary struct). If it has no chance as being a const param, then we create a `DefId` in `DefCollector` -- otherwise we decide during ast_lowering. This will have to be updated once all path consts use `ConstArgKind::Path`. - We explicitly use `ConstArgHasType` for array lengths, rather than implicitly relying on anon const type feeding -- this is due to the addition of `ConstArgKind::Path`. - Some tests have their outputs changed, but the changes are for the most part minor (including removing duplicate or almost-duplicate errors). One test now ICEs, but it is for an incomplete, unstable feature and is now tracked at #127009. 2024-07-16 19:07:36 -07:00			error: the constant `W` is not of type `usize`
			`--> $DIR/transmute-fail.rs:12:42`
			`\|`
			`LL \| fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {`
			\| ^^^^^^^^^^^^^ expected `usize`, found `bool`

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 09:45:19 +00:00			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:7:9`
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 09:45:19 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
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 09:45:19 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			= note: source type: `[[u32; H + 1]; W]` (size can vary because of [u32; H + 1])
			= note: target type: `[[u32; W + 1]; H]` (size can vary because of [u32; W + 1])
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 09:45:19 +00:00
Add `ConstArgKind::Path` and make `ConstArg` its own HIR node This is a very large commit since a lot needs to be changed in order to make the tests pass. The salient changes are: - `ConstArgKind` gets a new `Path` variant, and all const params are now represented using it. Non-param paths still use `ConstArgKind::Anon` to prevent this change from getting too large, but they will soon use the `Path` variant too. - `ConstArg` gets a distinct `hir_id` field and its own variant in `hir::Node`. This affected many parts of the compiler that expected the parent of an `AnonConst` to be the containing context (e.g., an array repeat expression). They have been changed to check the "grandparent" where necessary. - Some `ast::AnonConst`s now have their `DefId`s created in rustc_ast_lowering rather than `DefCollector`. This is because in some cases they will end up becoming a `ConstArgKind::Path` instead, which has no `DefId`. We have to solve this in a hacky way where we guess whether the `AnonConst` could end up as a path const since we can't know for sure until after name resolution (`N` could refer to a free const or a nullary struct). If it has no chance as being a const param, then we create a `DefId` in `DefCollector` -- otherwise we decide during ast_lowering. This will have to be updated once all path consts use `ConstArgKind::Path`. - We explicitly use `ConstArgHasType` for array lengths, rather than implicitly relying on anon const type feeding -- this is due to the addition of `ConstArgKind::Path`. - Some tests have their outputs changed, but the changes are for the most part minor (including removing duplicate or almost-duplicate errors). One test now ICEs, but it is for an incomplete, unstable feature and is now tracked at #127009. 2024-07-16 19:07:36 -07:00			error: the constant `W` is not of type `usize`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:17:9`
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 09:45:19 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			\| ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
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 09:45:19 +00:00
			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:24:9`
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 09:45:19 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
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 09:45:19 +00:00			`\|`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			= note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
			= note: target type: `[u32; W * H * H]` (this type does not have a fixed size)
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 09:45:19 +00:00
			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:31:9`
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 09:45:19 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
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 09:45:19 +00:00			`\|`
Don't ICE on unnormalized struct tail in layout computation 2023-06-19 19:57:44 +00:00			= note: source type: `[[[u32; 8888888]; 9999999]; 777777777]` (values of the type `[[u32; 8888888]; 9999999]` are too big for the current architecture)
			= note: target type: `[[[u32; 9999999]; 777777777]; 8888888]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)
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 09:45:19 +00:00
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:38:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
			= note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:49:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
			= note: target type: `[u32; W * H]` (this type does not have a fixed size)

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:56:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			= note: source type: `[u32; H * W]` (this type does not have a fixed size)
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			= note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:65:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
			= note: target type: `[u32; D * W * H]` (this type does not have a fixed size)

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:74:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
			= note: target type: `[[u32; D * W]; H]` (size can vary because of [u32; D * W])

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:81:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[u16; L]` (this type does not have a fixed size)
			= note: target type: `[u8; L * 2]` (this type does not have a fixed size)

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:88:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[u8; L * 2]` (this type does not have a fixed size)
			= note: target type: `[u16; L]` (this type does not have a fixed size)

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:95:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[u8; L]` (this type does not have a fixed size)
			= note: target type: `[[u8; 1]; L]` (this type does not have a fixed size)

			`error[E0512]: cannot transmute between types of different sizes, or dependently-sized types`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`--> $DIR/transmute-fail.rs:104:9`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`LL \| std::mem::transmute(v)`
			`\| ^^^^^^^^^^^^^^^^^^^`
Sorting arbitrary constants should not be done, as it relies on `DefId` ordering, which breaks incremental compilation. 2024-03-21 10:26:45 +00:00			`\|`
			= note: source type: `[[u32; 2 * H]; W + W]` (size can vary because of [u32; 2 * H])
			= note: target type: `[[u32; W + W]; 2 * H]` (size can vary because of [u32; W + W])

Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`error[E0308]: mismatched types`
			`--> $DIR/transmute-fail.rs:12:53`
			`\|`
			`LL \| fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {`
			\| ^ expected `usize`, found `bool`

			`error[E0308]: mismatched types`
			`--> $DIR/transmute-fail.rs:12:67`
			`\|`
			`LL \| fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {`
			\| ^ expected `usize`, found `bool`

			`error: aborting due to 16 previous errors`
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 09:45:19 +00:00
Retroactively feature gate `ConstArgKind::Path` 2024-08-19 01:14:09 +01:00			`Some errors have detailed explanations: E0308, E0512.`
			For more information about an error, try `rustc --explain E0308`.