mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Retroactively feature gate ConstArgKind::Path

Browse Source
This commit is contained in:
Boxy 2024-08-19 01:14:09 +01:00
parent f04f6ca36d
commit b8eedfa3d2
41 changed files with 425 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_ast_lowering/src/asm.rs
View File

@ -221,7 +221,9 @@ pub(crate) fn lower_inline_asm(
let parent_def_id = self.current_def_id_parent;
let node_id = self.next_node_id();
// HACK(min_generic_const_args): see lower_anon_const
if !expr.is_potential_trivial_const_arg() {
if !self.tcx.features().const_arg_path
|| !expr.is_potential_trivial_const_arg()
{
self.create_def(
parent_def_id,
node_id,

2
compiler/rustc_ast_lowering/src/expr.rs
View File

@ -387,7 +387,7 @@ fn lower_legacy_const_generics(
let node_id = self.next_node_id();
// HACK(min_generic_const_args): see lower_anon_const
if !arg.is_potential_trivial_const_arg() {
if !self.tcx.features().const_arg_path || !arg.is_potential_trivial_const_arg() {
// Add a definition for the in-band const def.
self.create_def(parent_def_id, node_id, kw::Empty, DefKind::AnonConst, f.span);
}

7
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -2358,7 +2358,7 @@ fn lower_const_path_to_const_arg(
span: Span,
) -> &'hir hir::ConstArg<'hir> {
let ct_kind = match res {
Res::Def(DefKind::ConstParam, _) => {
Res::Def(DefKind::ConstParam, _) if self.tcx.features().const_arg_path => {
let qpath = self.lower_qpath(
ty_id,
&None,
@ -2433,7 +2433,8 @@ fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::Con
self.resolver.get_partial_res(expr.id).and_then(|partial_res| partial_res.full_res());
debug!("res={:?}", maybe_res);
// FIXME(min_generic_const_args): for now we only lower params to ConstArgKind::Path
if let Some(res) = maybe_res
if self.tcx.features().const_arg_path
&& let Some(res) = maybe_res
&& let Res::Def(DefKind::ConstParam, _) = res
&& let ExprKind::Path(qself, path) = &expr.kind
{
@ -2464,7 +2465,7 @@ fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::Con
/// See [`hir::ConstArg`] for when to use this function vs
/// [`Self::lower_anon_const_to_const_arg`].
fn lower_anon_const_to_anon_const(&mut self, c: &AnonConst) -> &'hir hir::AnonConst {
if c.value.is_potential_trivial_const_arg() {
if self.tcx.features().const_arg_path && c.value.is_potential_trivial_const_arg() {
// HACK(min_generic_const_args): see DefCollector::visit_anon_const
// Over there, we guess if this is a bare param and only create a def if
// we think it's not. However we may can guess wrong (see there for example)

2
compiler/rustc_feature/src/unstable.rs
View File

@ -193,6 +193,8 @@ pub fn internal(&self, feature: Symbol) -> bool {
(unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
/// Allows identifying the `compiler_builtins` crate.
(internal, compiler_builtins, "1.13.0", None),
/// Gating for a new desugaring of const arguments of usages of const parameters
(internal, const_arg_path, "1.81.0", None),
/// Allows writing custom MIR
(internal, custom_mir, "1.65.0", None),
/// Outputs useful `assert!` messages

32
compiler/rustc_middle/src/ty/consts.rs
View File

@ -240,7 +240,7 @@ pub fn from_anon_const(tcx: TyCtxt<'tcx>, def: LocalDefId) -> Self {
let ty = tcx.type_of(def).no_bound_vars().expect("const parameter types cannot be generic");
match Self::try_from_lit(tcx, ty, expr) {
match Self::try_from_lit_or_param(tcx, ty, expr) {
Some(v) => v,
None => ty::Const::new_unevaluated(
tcx,
@ -281,7 +281,11 @@ fn from_param(tcx: TyCtxt<'tcx>, qpath: hir::QPath<'tcx>, hir_id: HirId) -> Self
}
#[instrument(skip(tcx), level = "debug")]
fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) -> Option<Self> {
fn try_from_lit_or_param(
tcx: TyCtxt<'tcx>,
ty: Ty<'tcx>,
expr: &'tcx hir::Expr<'tcx>,
) -> Option<Self> {
// Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
// currently have to be wrapped in curly brackets, so it's necessary to special-case.
let expr = match &expr.kind {
@ -291,6 +295,22 @@ fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) ->
_ => expr,
};
if let hir::ExprKind::Path(
qpath @ hir::QPath::Resolved(
_,
&hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
),
) = expr.kind
{
if tcx.features().const_arg_path {
span_bug!(
expr.span,
"try_from_lit: received const param which shouldn't be possible"
);
}
return Some(Const::from_param(tcx, qpath, expr.hir_id));
};
let lit_input = match expr.kind {
hir::ExprKind::Lit(lit) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
hir::ExprKind::Unary(hir::UnOp::Neg, expr) => match expr.kind {
@ -318,14 +338,6 @@ fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) ->
}
}
if let hir::ExprKind::Path(hir::QPath::Resolved(
_,
&hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
)) = expr.kind
{
span_bug!(expr.span, "try_from_lit: received const param which shouldn't be possible")
}
None
}

16
compiler/rustc_resolve/src/def_collector.rs
View File

@ -314,13 +314,15 @@ fn visit_pat(&mut self, pat: &'a Pat) {
}
fn visit_anon_const(&mut self, constant: &'a AnonConst) {
// HACK(min_generic_const_args): don't create defs for anon consts if we think they will
// later be turned into ConstArgKind::Path's. because this is before resolve is done, we
// may accidentally identify a construction of a unit struct as a param and not create a
// def. we'll then create a def later in ast lowering in this case. the parent of nested
// items will be messed up, but that's ok because there can't be any if we're just looking
// for bare idents.
if constant.value.is_potential_trivial_const_arg() {
if self.resolver.tcx.features().const_arg_path
&& constant.value.is_potential_trivial_const_arg()
{
// HACK(min_generic_const_args): don't create defs for anon consts if we think they will
// later be turned into ConstArgKind::Path's. because this is before resolve is done, we
// may accidentally identify a construction of a unit struct as a param and not create a
// def. we'll then create a def later in ast lowering in this case. the parent of nested
// items will be messed up, but that's ok because there can't be any if we're just looking
// for bare idents.
visit::walk_anon_const(self, constant)
} else {
let def =

1
compiler/rustc_span/src/symbol.rs
View File

@ -595,6 +595,7 @@
conservative_impl_trait,
console,
const_allocate,
const_arg_path,
const_async_blocks,
const_closures,
const_compare_raw_pointers,

2
tests/crashes/127972.rs
View File

@ -1,5 +1,5 @@
//@ known-bug: #127962
#![feature(generic_const_exprs)]
#![feature(generic_const_exprs, const_arg_path)]
fn zero_init<const usize: usize>() -> Substs1<{ (N) }> {
Substs1([0; { (usize) }])

10
tests/crashes/128016.rs
View File

@ -1,10 +0,0 @@
//@ known-bug: #128016
macro_rules! len {
() => {
target
};
}
fn main() {
let val: [str; len!()] = [];
}

10
tests/ui-fulldeps/stable-mir/check_instance.rs
View File

@ -17,12 +17,14 @@
extern crate rustc_interface;
extern crate stable_mir;
use mir::{mono::Instance, TerminatorKind::*};
use std::io::Write;
use std::ops::ControlFlow;
use mir::mono::Instance;
use mir::TerminatorKind::*;
use rustc_smir::rustc_internal;
use stable_mir::ty::{RigidTy, TyKind};
use stable_mir::*;
use std::io::Write;
use std::ops::ControlFlow;
const CRATE_NAME: &str = "input";
@ -33,7 +35,7 @@ fn test_stable_mir() -> ControlFlow<()> {
// Get all items and split generic vs monomorphic items.
let (generic, mono): (Vec<_>, Vec<_>) =
items.into_iter().partition(|item| item.requires_monomorphization());
assert_eq!(mono.len(), 3, "Expected 3 mono functions");
assert_eq!(mono.len(), 4, "Expected 3 mono functions");
assert_eq!(generic.len(), 2, "Expected 2 generic functions");
// For all monomorphic items, get the correspondent instances.

2
tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
View File

@ -5,7 +5,9 @@
#![feature(with_negative_coherence)]
trait Trait {}
impl<const N: u8> Trait for [(); N] {}
//~^ ERROR: mismatched types
impl<const N: i8> Trait for [(); N] {}
//~^ ERROR: conflicting implementations of trait `Trait`
//~| ERROR: mismatched types
fn main() {}

20
tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
View File

@ -1,11 +1,25 @@
error[E0119]: conflicting implementations of trait `Trait` for type `[(); _]`
--> $DIR/generic_const_type_mismatch.rs:8:1
--> $DIR/generic_const_type_mismatch.rs:9:1
|
LL | impl<const N: u8> Trait for [(); N] {}
| ----------------------------------- first implementation here
LL |
LL | impl<const N: i8> Trait for [(); N] {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); _]`
error: aborting due to 1 previous error
error[E0308]: mismatched types
--> $DIR/generic_const_type_mismatch.rs:7:34
|
LL | impl<const N: u8> Trait for [(); N] {}
| ^ expected `usize`, found `u8`
For more information about this error, try `rustc --explain E0119`.
error[E0308]: mismatched types
--> $DIR/generic_const_type_mismatch.rs:9:34
|
LL | impl<const N: i8> Trait for [(); N] {}
| ^ expected `usize`, found `i8`
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0119, E0308.
For more information about an error, try `rustc --explain E0119`.

1
tests/ui/const-generics/bad-subst-const-kind.rs
View File

@ -7,6 +7,7 @@ trait Q {
impl<const N: u64> Q for [u8; N] {
//~^ ERROR: the constant `N` is not of type `usize`
//~| ERROR: mismatched types
const ASSOC: usize = 1;
}

11
tests/ui/const-generics/bad-subst-const-kind.stderr
View File

@ -5,7 +5,7 @@ LL | impl<const N: u64> Q for [u8; N] {
| ^^^^^^^ expected `usize`, found `u64`
error: the constant `13` is not of type `u64`
--> $DIR/bad-subst-const-kind.rs:13:24
--> $DIR/bad-subst-const-kind.rs:14:24
|
LL | pub fn test() -> [u8; <[u8; 13] as Q>::ASSOC] {
| ^^^^^^^^ expected `u64`, found `usize`
@ -18,5 +18,12 @@ LL | impl<const N: u64> Q for [u8; N] {
| |
| unsatisfied trait bound introduced here
error: aborting due to 2 previous errors
error[E0308]: mismatched types
--> $DIR/bad-subst-const-kind.rs:8:31
|
LL | impl<const N: u64> Q for [u8; N] {
| ^ expected `usize`, found `u64`
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0308`.

21
tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs Normal file
View File

@ -0,0 +1,21 @@
//@ check-pass
// This is a regression test for #128016.
macro_rules! len_inner {
() => {
BAR
};
}
macro_rules! len {
() => {
len_inner!()
};
}
const BAR: usize = 0;
fn main() {
let val: [bool; len!()] = [];
}

13
tests/ui/const-generics/early/trivial-const-arg-macro-param.rs Normal file
View File

@ -0,0 +1,13 @@
//@ check-pass
macro_rules! len {
($x:ident) => {
$x
};
}
fn bar<const N: usize>() {
let val: [bool; len!(N)] = [true; N];
}
fn main() {}

13
tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs Normal file
View File

@ -0,0 +1,13 @@
// This is a regression test for #128016.
macro_rules! len {
() => {
target
//~^ ERROR cannot find value `target`
};
}
fn main() {
let val: [str; len!()] = [];
//~^ ERROR the size for values
}

24
tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr Normal file
View File

@ -0,0 +1,24 @@
error[E0425]: cannot find value `target` in this scope
--> $DIR/trivial-const-arg-macro-res-error.rs:5:9
|
LL | target
| ^^^^^^ not found in this scope
...
LL | let val: [str; len!()] = [];
| ------ in this macro invocation
|
= note: this error originates in the macro `len` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0277]: the size for values of type `str` cannot be known at compilation time
--> $DIR/trivial-const-arg-macro-res-error.rs:11:14
|
LL | let val: [str; len!()] = [];
| ^^^^^^^^^^^^^ doesn't have a size known at compile-time
|
= help: the trait `Sized` is not implemented for `str`
= note: slice and array elements must have `Sized` type
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0277, E0425.
For more information about an error, try `rustc --explain E0277`.

15
tests/ui/const-generics/early/trivial-const-arg-macro.rs Normal file
View File

@ -0,0 +1,15 @@
//@ check-pass
// This is a regression test for #128016.
macro_rules! len {
() => {
BAR
};
}
const BAR: usize = 0;
fn main() {
let val: [bool; len!()] = [];
}

1
tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
View File

@ -8,6 +8,7 @@ trait Q {
impl<const N: u64> Q for [u8; N] {}
//~^ ERROR not all trait items implemented
//~| ERROR the constant `N` is not of type `usize`
//~| ERROR mismatched types
pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
//~^ ERROR the constant `13` is not of type `u64`

12
tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
View File

@ -14,7 +14,7 @@ LL | impl<const N: u64> Q for [u8; N] {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `ASSOC` in implementation
error: the constant `13` is not of type `u64`
--> $DIR/type_mismatch.rs:12:26
--> $DIR/type_mismatch.rs:13:26
|
LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
| ^^^^^^^^ expected `u64`, found `usize`
@ -28,14 +28,20 @@ LL | impl<const N: u64> Q for [u8; N] {}
| unsatisfied trait bound introduced here
error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:12:20
--> $DIR/type_mismatch.rs:13:20
|
LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
| ------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `[u8; <[u8; 13] as Q>::ASSOC]`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
error: aborting due to 4 previous errors
error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:8:31
|
LL | impl<const N: u64> Q for [u8; N] {}
| ^ expected `usize`, found `u64`
error: aborting due to 5 previous errors
Some errors have detailed explanations: E0046, E0308.
For more information about an error, try `rustc --explain E0046`.

10
tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
View File

@ -14,8 +14,8 @@ mod v20 {
//~^ ERROR cannot find value `v8` in this scope
//~| ERROR cannot find function `v6` in this scope
pub struct v17<const v10: usize, const v7: v11> {
//~^ WARN type `v17` should have an upper camel case name
//~| ERROR `[[usize; v4]; v4]` is forbidden as the type of a const generic parameter
//~^ WARN type `v17` should have an upper camel case name
//~| ERROR `[[usize; v4]; v4]` is forbidden as the type of a const generic parameter
_p: (),
}
@ -25,10 +25,10 @@ pub const fn v21() -> v18 {}
}
impl<const v10: usize> v17<v10, v2> {
//~^ ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
//~| ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
//~^ ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
//~| ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
pub const fn v21() -> v18 {
//~^ ERROR cannot find type `v18` in this scope
//~^ ERROR cannot find type `v18` in this scope
v18 { _p: () }
//~^ ERROR cannot find struct, variant or union type `v18` in this scope
}

4
tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
View File

@ -72,13 +72,13 @@ help: add `#![feature(adt_const_params)]` to the crate attributes to enable more
LL + #![feature(adt_const_params)]
|
error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
--> $DIR/unevaluated-const-ice-119731.rs:27:37
|
LL | impl<const v10: usize> v17<v10, v2> {
| ^^
error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
--> $DIR/unevaluated-const-ice-119731.rs:27:37
|
LL | impl<const v10: usize> v17<v10, v2> {

126
tests/ui/const-generics/transmute-fail.rs
View File

@ -2,108 +2,108 @@
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
fn foo<const W: usize, const H: usize>(v: [[u32;H+1]; W]) -> [[u32; W+1]; H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR cannot transmute
}
fn foo<const W: usize, const H: usize>(v: [[u32; H + 1]; W]) -> [[u32; W + 1]; H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR cannot transmute
}
}
fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
//~^ ERROR the constant `W` is not of type `usize`
unsafe {
std::mem::transmute(v)
//~^ ERROR the constant `W` is not of type `usize`
}
//~^ ERROR: the constant `W` is not of type `usize`
//~| ERROR: mismatched types
//~| ERROR: mismatched types
unsafe {
std::mem::transmute(v)
//~^ ERROR: the constant `W` is not of type `usize`
}
}
fn baz<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [u32; W * H * H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR cannot transmute
}
unsafe {
std::mem::transmute(v)
//~^ ERROR cannot transmute
}
}
fn overflow(v: [[[u32; 8888888]; 9999999]; 777777777]) -> [[[u32; 9999999]; 777777777]; 8888888] {
unsafe {
std::mem::transmute(v)
//~^ ERROR cannot transmute
}
unsafe {
std::mem::transmute(v)
//~^ ERROR cannot transmute
}
}
fn transpose<const W: usize, const H: usize>(v: [[u32;H]; W]) -> [[u32; W]; H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
fn transpose<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn ident<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; H]; W] {
unsafe {
std::mem::transmute(v)
}
unsafe { std::mem::transmute(v) }
}
fn flatten<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [u32; W * H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn coagulate<const W: usize, const H: usize>(v: [u32; H*W]) -> [[u32; W];H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
fn coagulate<const W: usize, const H: usize>(v: [u32; H * W]) -> [[u32; W]; H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn flatten_3d<const W: usize, const H: usize, const D: usize>(
v: [[[u32; D]; H]; W]
v: [[[u32; D]; H]; W],
) -> [u32; D * W * H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn flatten_somewhat<const W: usize, const H: usize, const D: usize>(
v: [[[u32; D]; H]; W]
v: [[[u32; D]; H]; W],
) -> [[u32; D * W]; H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn known_size<const L: usize>(v: [u16; L]) -> [u8; L * 2] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn condense_bytes<const L: usize>(v: [u8; L * 2]) -> [u16; L] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn singleton_each<const L: usize>(v: [u8; L]) -> [[u8;1]; L] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
fn singleton_each<const L: usize>(v: [u8; L]) -> [[u8; 1]; L] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn transpose_with_const<const W: usize, const H: usize>(
v: [[u32; 2 * H]; W + W]
v: [[u32; 2 * H]; W + W],
) -> [[u32; W + W]; 2 * H] {
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
unsafe {
std::mem::transmute(v)
//~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
}
}
fn main() {}

101
tests/ui/const-generics/transmute-fail.stderr
View File

@ -5,119 +5,132 @@ 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:5
--> $DIR/transmute-fail.rs:7:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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])
= 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:15:5
--> $DIR/transmute-fail.rs:17:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
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:22:5
--> $DIR/transmute-fail.rs:24:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:29:5
--> $DIR/transmute-fail.rs:31:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:36:5
--> $DIR/transmute-fail.rs:38:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:49:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:56:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
|
= note: source type: `[u32; H*W]` (this type does not have a fixed size)
= 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:5
--> $DIR/transmute-fail.rs:65:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:74:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:81:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:88:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:95:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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:5
--> $DIR/transmute-fail.rs:104:9
|
LL | std::mem::transmute(v)
| ^^^^^^^^^^^^^^^^^^^
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: aborting due to 14 previous errors
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`
For more information about this error, try `rustc --explain E0512`.
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`.

2
tests/ui/const-generics/type_mismatch.rs
View File

@ -1,10 +1,12 @@
fn foo<const N: usize>() -> [u8; N] {
bar::<N>()
//~^ ERROR the constant `N` is not of type `u8`
//~| ERROR: mismatched types
}
fn bar<const N: u8>() -> [u8; N] {}
//~^ ERROR the constant `N` is not of type `usize`
//~| ERROR: mismatched types
//~| ERROR mismatched types
fn main() {}

20
tests/ui/const-generics/type_mismatch.stderr
View File

@ -1,5 +1,5 @@
error: the constant `N` is not of type `usize`
--> $DIR/type_mismatch.rs:6:26
--> $DIR/type_mismatch.rs:7:26
|
LL | fn bar<const N: u8>() -> [u8; N] {}
| ^^^^^^^ expected `usize`, found `u8`
@ -11,19 +11,31 @@ LL | bar::<N>()
| ^ expected `u8`, found `usize`
|
note: required by a const generic parameter in `bar`
--> $DIR/type_mismatch.rs:6:8
--> $DIR/type_mismatch.rs:7:8
|
LL | fn bar<const N: u8>() -> [u8; N] {}
| ^^^^^^^^^^^ required by this const generic parameter in `bar`
error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:6:26
--> $DIR/type_mismatch.rs:7:26
|
LL | fn bar<const N: u8>() -> [u8; N] {}
| --- ^^^^^^^ expected `[u8; N]`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
error: aborting due to 3 previous errors
error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:2:11
|
LL | bar::<N>()
| ^ expected `u8`, found `usize`
error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:7:31
|
LL | fn bar<const N: u8>() -> [u8; N] {}
| ^ expected `usize`, found `u8`
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0308`.

6
tests/ui/consts/issue-36163.stderr
View File

@ -1,10 +1,10 @@
error[E0391]: cycle detected when simplifying constant for the type system `Foo::{constant#0}`
error[E0391]: cycle detected when simplifying constant for the type system `Foo::B::{constant#0}`
--> $DIR/issue-36163.rs:4:9
|
LL | B = A,
| ^
|
note: ...which requires const-evaluating + checking `Foo::{constant#0}`...
note: ...which requires const-evaluating + checking `Foo::B::{constant#0}`...
--> $DIR/issue-36163.rs:4:9
|
LL | B = A,
@ -19,7 +19,7 @@ note: ...which requires const-evaluating + checking `A`...
|
LL | const A: isize = Foo::B as isize;
| ^^^^^^^^^^^^^^^
= note: ...which again requires simplifying constant for the type system `Foo::{constant#0}`, completing the cycle
= note: ...which again requires simplifying constant for the type system `Foo::B::{constant#0}`, completing the cycle
note: cycle used when checking that `Foo` is well-formed
--> $DIR/issue-36163.rs:3:1
|

5
tests/ui/feature-gates/feature-gate-const-arg-path.rs Normal file
View File

@ -0,0 +1,5 @@
//@ check-pass
// this doesn't really have any user facing impact....
fn main() {}

7
tests/ui/lifetimes/issue-95023.rs
View File

@ -2,12 +2,13 @@
struct Error(ErrorKind);
impl Fn(&isize) for Error {
//~^ ERROR manual implementations of `Fn` are experimental [E0183]
//~^^ ERROR associated item constraints are not allowed here [E0229]
//~| ERROR associated item constraints are not allowed here [E0229]
//~| ERROR not all trait items implemented
//~| ERROR expected a `FnMut(&isize)` closure, found `Error`
fn foo<const N: usize>(&self) -> Self::B<{ N }>;
//~^ ERROR associated function in `impl` without body
//~^^ ERROR method `foo` is not a member of trait `Fn` [E0407]
//~^^^ ERROR associated type `B` not found for `Self` [E0220]
//~| ERROR method `foo` is not a member of trait `Fn` [E0407]
//~| ERROR associated type `B` not found for `Self` [E0220]
//~| ERROR: associated type `B` not found for `Self`
}
fn main() {}

10
tests/ui/lifetimes/issue-95023.stderr
View File

@ -56,7 +56,15 @@ error[E0220]: associated type `B` not found for `Self`
LL | fn foo<const N: usize>(&self) -> Self::B<{ N }>;
| ^ help: `Self` has the following associated type: `Output`
error: aborting due to 7 previous errors
error[E0220]: associated type `B` not found for `Self`
--> $DIR/issue-95023.rs:8:44
|
LL | fn foo<const N: usize>(&self) -> Self::B<{ N }>;
| ^ help: `Self` has the following associated type: `Output`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: aborting due to 8 previous errors
Some errors have detailed explanations: E0046, E0183, E0220, E0229, E0277, E0407.
For more information about an error, try `rustc --explain E0046`.

1
tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
View File

@ -14,5 +14,6 @@ struct Wrapper<const C: <i32 as Trait>::Type> {}
impl<const C: usize> Wrapper<C> {}
//~^ ERROR the constant `C` is not of type `<i32 as Trait>::Type`
//~| ERROR: mismatched types
fn main() {}

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

@ -20,5 +20,17 @@ note: required by a const generic parameter in `Wrapper`
LL | struct Wrapper<const C: <i32 as Trait>::Type> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Wrapper`
error: aborting due to 2 previous errors
error[E0308]: mismatched types
--> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30
|
LL | impl<const C: usize> Wrapper<C> {}
| ^ expected associated type, found `usize`
|
= note: expected associated type `<i32 as Trait>::Type`
found type `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
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0308`.

1
tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
View File

@ -6,6 +6,7 @@
struct S<const L: usize>;
impl<const N: i32> Copy for S<N> {}
//~^ ERROR: mismatched types
impl<const M: usize> Copy for S<M> {}
//~^ ERROR: conflicting implementations of trait `Copy` for type `S<_>`

14
tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.stderr
View File

@ -1,11 +1,19 @@
error[E0119]: conflicting implementations of trait `Copy` for type `S<_>`
--> $DIR/bad-const-wf-doesnt-specialize.rs:9:1
--> $DIR/bad-const-wf-doesnt-specialize.rs:10:1
|
LL | impl<const N: i32> Copy for S<N> {}
| -------------------------------- first implementation here
LL |
LL | impl<const M: usize> Copy for S<M> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `S<_>`
error: aborting due to 1 previous error
error[E0308]: mismatched types
--> $DIR/bad-const-wf-doesnt-specialize.rs:8:31
|
LL | impl<const N: i32> Copy for S<N> {}
| ^ expected `usize`, found `i32`
For more information about this error, try `rustc --explain E0119`.
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0119, E0308.
For more information about an error, try `rustc --explain E0119`.

3
tests/ui/transmutability/issue-101739-1.rs
View File

@ -6,7 +6,8 @@ mod assert {
pub fn is_transmutable<Src, const ASSUME_ALIGNMENT: bool>()
where
Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
//~^ the constant `ASSUME_ALIGNMENT` is not of type `Assume`
//~| the constant `ASSUME_ALIGNMENT` is not of type `Assume`
//~| ERROR: mismatched types
{
}
}

11
tests/ui/transmutability/issue-101739-1.stderr
View File

@ -13,6 +13,13 @@ LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
note: required by a const generic parameter in `BikeshedIntrinsicFrom`
--> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
error: aborting due to 2 previous errors
error[E0308]: mismatched types
--> $DIR/issue-101739-1.rs:8:41
|
LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
| ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
For more information about this error, try `rustc --explain E0412`.
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0308, E0412.
For more information about an error, try `rustc --explain E0308`.

24
tests/ui/transmutability/issue-101739-2.rs
View File

@ -14,19 +14,23 @@ pub fn is_transmutable<
const ASSUME_VISIBILITY: bool,
>()
where
Dst: BikeshedIntrinsicFrom< //~ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
Src,
ASSUME_ALIGNMENT,
ASSUME_LIFETIMES,
ASSUME_VALIDITY,
ASSUME_VISIBILITY,
>,
{}
Dst: BikeshedIntrinsicFrom<
//~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
Src,
ASSUME_ALIGNMENT, //~ ERROR: mismatched types
ASSUME_LIFETIMES,
ASSUME_VALIDITY,
ASSUME_VISIBILITY,
>,
{
}
}
fn via_const() {
#[repr(C)] struct Src;
#[repr(C)] struct Dst;
#[repr(C)]
struct Src;
#[repr(C)]
struct Dst;
const FALSE: bool = false;

25
tests/ui/transmutability/issue-101739-2.stderr
View File

@ -3,14 +3,21 @@ error[E0107]: trait takes at most 2 generic arguments but 5 generic arguments we
|
LL | Dst: BikeshedIntrinsicFrom<
| ^^^^^^^^^^^^^^^^^^^^^ expected at most 2 generic arguments
LL | Src,
LL | ASSUME_ALIGNMENT,
| _____________________________-
LL | | ASSUME_LIFETIMES,
LL | | ASSUME_VALIDITY,
LL | | ASSUME_VISIBILITY,
| |_____________________________- help: remove the unnecessary generic arguments
...
LL | ASSUME_ALIGNMENT,
| _________________________________-
LL | | ASSUME_LIFETIMES,
LL | | ASSUME_VALIDITY,
LL | | ASSUME_VISIBILITY,
| |_________________________________- help: remove the unnecessary generic arguments
error: aborting due to 1 previous error
error[E0308]: mismatched types
--> $DIR/issue-101739-2.rs:20:17
|
LL | ASSUME_ALIGNMENT,
| ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
For more information about this error, try `rustc --explain E0107`.
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0107, E0308.
For more information about an error, try `rustc --explain E0107`.

8
tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
View File

@ -3,16 +3,18 @@
// of an impl fn produces a type mismatch error instead of triggering
// a const eval cycle
trait Trait {
fn func<const N: u32>() -> [ (); N ]; //~ ERROR the constant `N` is not of type `usize`
fn func<const N: u32>() -> [(); N];
//~^ ERROR: the constant `N` is not of type `usize`
//~| ERROR: mismatched types
}
struct S {}
#[allow(unused_braces)]
impl Trait for S {
fn func<const N: u32>() -> [ (); { () }] { //~ ERROR mismatched types
fn func<const N: u32>() -> [(); { () }] {
//~^ ERROR mismatched types
N
}
}

20
tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
View File

@ -1,15 +1,21 @@
error[E0308]: mismatched types
--> $DIR/const-in-impl-fn-return-type.rs:15:40
--> $DIR/const-in-impl-fn-return-type.rs:16:39
|
LL | fn func<const N: u32>() -> [ (); { () }] {
| ^^ expected `usize`, found `()`
LL | fn func<const N: u32>() -> [(); { () }] {
| ^^ expected `usize`, found `()`
error: the constant `N` is not of type `usize`
--> $DIR/const-in-impl-fn-return-type.rs:8:32
--> $DIR/const-in-impl-fn-return-type.rs:7:32
|
LL | fn func<const N: u32>() -> [ (); N ];
| ^^^^^^^^^ expected `usize`, found `u32`
LL | fn func<const N: u32>() -> [(); N];
| ^^^^^^^ expected `usize`, found `u32`
error: aborting due to 2 previous errors
error[E0308]: mismatched types
--> $DIR/const-in-impl-fn-return-type.rs:7:37
|
LL | fn func<const N: u32>() -> [(); N];
| ^ expected `usize`, found `u32`
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0308`.