nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-22 11:53:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #90207 - BoxyUwU:stabilise_cg_defaults, r=lcnr

Browse Source 
Stabilise `feature(const_generics_defaults)`

`feature(const_generics_defaults)` is complete implementation wise and has a pretty extensive test suite so I think is ready for stabilisation.

needs stabilisation report and maybe an RFC 😅

r? `@lcnr`
cc `@rust-lang/project-const-generics`
This commit is contained in:
bors 2021-12-12 14:24:23 +00:00
commit 753e569c9c
94 changed files with 101 additions and 380 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
compiler/rustc_ast/src/ast.rs
View File

@ -332,10 +332,7 @@ pub type GenericBounds = Vec<GenericBound>;
pub enum ParamKindOrd {
Lifetime,
Type,
// `unordered` is only `true` if `sess.unordered_const_ty_params()`
// returns true. Specifically, if it's only `min_const_generics`, it will still require
// ordering consts after types.
Const { unordered: bool },
Const,
// `Infer` is not actually constructed directly from the AST, but is implicitly constructed
// during HIR lowering, and `ParamKindOrd` will implicitly order inferred variables last.
Infer,
@ -346,11 +343,7 @@ impl Ord for ParamKindOrd {
use ParamKindOrd::*;
let to_int = |v| match v {
Lifetime => 0,
Infer | Type | Const { unordered: true } => 1,
// technically both consts should be ordered equally,
// but only one is ever encountered at a time, so this is
// fine.
Const { unordered: false } => 2,
Infer | Type | Const => 1,
};
to_int(*self).cmp(&to_int(*other))

28
compiler/rustc_ast_passes/src/ast_validation.rs
View File

@ -894,7 +894,6 @@ impl<'a> AstValidator<'a> {
/// Checks that generic parameters are in the correct order,
/// which is lifetimes, then types and then consts. (`<'a, T, const N: usize>`)
fn validate_generic_param_order(
sess: &Session,
handler: &rustc_errors::Handler,
generics: &[GenericParam],
span: Span,
@ -911,8 +910,7 @@ fn validate_generic_param_order(
GenericParamKind::Type { default: _ } => (ParamKindOrd::Type, ident.to_string()),
GenericParamKind::Const { ref ty, kw_span: _, default: _ } => {
let ty = pprust::ty_to_string(ty);
let unordered = sess.features_untracked().unordered_const_ty_params();
(ParamKindOrd::Const { unordered }, format!("const {}: {}", ident, ty))
(ParamKindOrd::Const, format!("const {}: {}", ident, ty))
}
};
param_idents.push((kind, ord_kind, bounds, idx, ident));
@ -968,14 +966,7 @@ fn validate_generic_param_order(
);
err.span_suggestion(
span,
&format!(
"reorder the parameters: lifetimes, {}",
if sess.features_untracked().unordered_const_ty_params() {
"then consts and types"
} else {
"then types, then consts"
}
),
"reorder the parameters: lifetimes, then consts and types",
ordered_params.clone(),
Applicability::MachineApplicable,
);
@ -1342,8 +1333,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
fn visit_generics(&mut self, generics: &'a Generics) {
let cg_defaults = self.session.features_untracked().unordered_const_ty_params();
let mut prev_param_default = None;
for param in &generics.params {
match param.kind {
@ -1358,12 +1347,6 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
span,
"generic parameters with a default must be trailing",
);
if matches!(param.kind, GenericParamKind::Const { .. }) && !cg_defaults {
err.note(
"using type defaults and const parameters \
in the same parameter list is currently not permitted",
);
}
err.emit();
break;
}
@ -1371,12 +1354,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
}
validate_generic_param_order(
self.session,
self.err_handler(),
&generics.params,
generics.span,
);
validate_generic_param_order(self.err_handler(), &generics.params, generics.span);
for predicate in &generics.where_clause.predicates {
if let WherePredicate::EqPredicate(ref predicate) = *predicate {

4
compiler/rustc_ast_passes/src/feature_gate.rs
View File

@ -724,10 +724,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
gate_all!(half_open_range_patterns, "half-open range patterns are unstable");
gate_all!(inline_const, "inline-const is experimental");
gate_all!(inline_const_pat, "inline-const in pattern position is experimental");
gate_all!(
const_generics_defaults,
"default values for const generic parameters are experimental"
);
if sess.parse_sess.span_diagnostic.err_count() == 0 {
// Errors for `destructuring_assignment` can get quite noisy, especially where `_` is
// involved, so we only emit errors where there are no other parsing errors.

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

@ -90,6 +90,8 @@ declare_features! (
(accepted, const_fn_union, "1.56.0", Some(51909), None),
/// Allows unsizing coercions in `const fn`.
(accepted, const_fn_unsize, "1.54.0", Some(64992), None),
/// Allows const generics to have default values (e.g. `struct Foo<const N: usize = 3>(...);`).
(accepted, const_generics_defaults, "1.59.0", Some(44580), None),
/// Allows the use of `if` and `match` in constants.
(accepted, const_if_match, "1.46.0", Some(49146), None),
/// Allows indexing into constant arrays.

6
compiler/rustc_feature/src/active.rs
View File

@ -69,10 +69,6 @@ macro_rules! declare_features {
}
}
pub fn unordered_const_ty_params(&self) -> bool {
self.const_generics_defaults || self.generic_const_exprs || self.adt_const_params
}
/// Some features are known to be incomplete and using them is likely to have
/// unanticipated results, such as compiler crashes. We warn the user about these
/// to alert them.
@ -334,8 +330,6 @@ declare_features! (
(active, const_fn_trait_bound, "1.53.0", Some(57563), None),
/// Allows `for _ in _` loops in const contexts.
(active, const_for, "1.56.0", Some(87575), None),
/// Allows const generics to have default values (e.g. `struct Foo<const N: usize = 3>(...);`).
(active, const_generics_defaults, "1.51.0", Some(44580), None),
/// Allows argument and return position `impl Trait` in a `const fn`.
(active, const_impl_trait, "1.48.0", Some(77463), None),
/// Allows using `&mut` in constant functions.

6
compiler/rustc_hir/src/hir.rs
View File

@ -325,13 +325,11 @@ impl GenericArg<'_> {
}
}
pub fn to_ord(&self, feats: &rustc_feature::Features) -> ast::ParamKindOrd {
pub fn to_ord(&self) -> ast::ParamKindOrd {
match self {
GenericArg::Lifetime(_) => ast::ParamKindOrd::Lifetime,
GenericArg::Type(_) => ast::ParamKindOrd::Type,
GenericArg::Const(_) => {
ast::ParamKindOrd::Const { unordered: feats.unordered_const_ty_params() }
}
GenericArg::Const(_) => ast::ParamKindOrd::Const,
GenericArg::Infer(_) => ast::ParamKindOrd::Infer,
}
}

6
compiler/rustc_middle/src/ty/generics.rs
View File

@ -24,13 +24,11 @@ impl GenericParamDefKind {
GenericParamDefKind::Const { .. } => "constant",
}
}
pub fn to_ord(&self, tcx: TyCtxt<'_>) -> ast::ParamKindOrd {
pub fn to_ord(&self) -> ast::ParamKindOrd {
match self {
GenericParamDefKind::Lifetime => ast::ParamKindOrd::Lifetime,
GenericParamDefKind::Type { .. } => ast::ParamKindOrd::Type,
GenericParamDefKind::Const { .. } => {
ast::ParamKindOrd::Const { unordered: tcx.features().unordered_const_ty_params() }
}
GenericParamDefKind::Const { .. } => ast::ParamKindOrd::Const,
}
}
}

17
compiler/rustc_parse/src/parser/generics.rs
View File

@ -5,7 +5,7 @@ use rustc_ast::{
self as ast, Attribute, GenericBounds, GenericParam, GenericParamKind, WhereClause,
};
use rustc_errors::PResult;
use rustc_span::symbol::{kw, sym};
use rustc_span::symbol::kw;
impl<'a> Parser<'a> {
/// Parses bounds of a lifetime parameter `BOUND + BOUND + BOUND`, possibly with trailing `+`.
@ -59,19 +59,8 @@ impl<'a> Parser<'a> {
self.expect(&token::Colon)?;
let ty = self.parse_ty()?;
// Parse optional const generics default value, taking care of feature gating the spans
// with the unstable syntax mechanism.
let default = if self.eat(&token::Eq) {
// The gated span goes from the `=` to the end of the const argument that follows (and
// which could be a block expression).
let start = self.prev_token.span;
let const_arg = self.parse_const_arg()?;
let span = start.to(const_arg.value.span);
self.sess.gated_spans.gate(sym::const_generics_defaults, span);
Some(const_arg)
} else {
None
};
// Parse optional const generics default value.
let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None };
Ok(GenericParam {
ident,

36
compiler/rustc_typeck/src/astconv/generics.rs
View File

@ -131,8 +131,8 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
_ => {}
}
let kind_ord = param.kind.to_ord(tcx);
let arg_ord = arg.to_ord(tcx.features());
let kind_ord = param.kind.to_ord();
let arg_ord = arg.to_ord();
// This note is only true when generic parameters are strictly ordered by their kind.
if possible_ordering_error && kind_ord.cmp(&arg_ord) != core::cmp::Ordering::Equal {
@ -298,26 +298,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
.params
.clone()
.into_iter()
.map(|param| {
(
match param.kind {
GenericParamDefKind::Lifetime => {
ParamKindOrd::Lifetime
}
GenericParamDefKind::Type { .. } => {
ParamKindOrd::Type
}
GenericParamDefKind::Const { .. } => {
ParamKindOrd::Const {
unordered: tcx
.features()
.unordered_const_ty_params(),
}
}
},
param,
)
})
.map(|param| (param.kind.to_ord(), param))
.collect::<Vec<(ParamKindOrd, GenericParamDef)>>();
param_types_present.sort_by_key(|(ord, _)| *ord);
let (mut param_types_present, ordered_params): (
@ -330,16 +311,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
tcx,
arg,
param,
!args_iter.clone().is_sorted_by_key(|arg| match arg {
GenericArg::Lifetime(_) => ParamKindOrd::Lifetime,
GenericArg::Type(_) => ParamKindOrd::Type,
GenericArg::Const(_) => ParamKindOrd::Const {
unordered: tcx
.features()
.unordered_const_ty_params(),
},
GenericArg::Infer(_) => ParamKindOrd::Infer,
}),
!args_iter.clone().is_sorted_by_key(|arg| arg.to_ord()),
Some(&format!(
"reorder the arguments: {}: `<{}>`",
param_types_present

1
compiler/rustc_typeck/src/check/wfcheck.rs
View File

@ -697,7 +697,6 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. } => (),
// Const parameters are well formed if their type is structural match.
// FIXME(const_generics_defaults): we also need to check that the `default` is wf.
hir::GenericParamKind::Const { ty: hir_ty, default: _ } => {
let ty = tcx.type_of(tcx.hir().local_def_id(param.hir_id));

2
src/test/incremental/const-generics/hash-tyvid-regression-2.rs
View File

@ -1,5 +1,5 @@
// revisions: cfail
#![feature(generic_const_exprs, adt_const_params, const_generics_defaults)]
#![feature(generic_const_exprs, adt_const_params)]
#![allow(incomplete_features)]
// regression test for #77650
struct C<T, const N: core::num::NonZeroUsize>([T; N.get()])

1
src/test/rustdoc/const-generics/const-generic-defaults.rs
View File

@ -1,5 +1,4 @@
#![crate_name = "foo"]
#![feature(const_generics_defaults)]
// @has foo/struct.Foo.html '//pre[@class="rust struct"]' \
// 'pub struct Foo<const M: usize = 10_usize, const N: usize = M, T = i32>(_);'

30
src/test/ui/const-generics/argument_order.min.stderr
View File

@ -1,30 +0,0 @@
error: type parameters must be declared prior to const parameters
--> $DIR/argument_order.rs:4:28
|
LL | struct Bad<const N: usize, T> {
| -----------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const N: usize>`
error: lifetime parameters must be declared prior to const parameters
--> $DIR/argument_order.rs:10:32
|
LL | struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
| -----------------^^-----^^-------------------- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T, U, const N: usize, const M: usize>`
error: type parameters must be declared prior to const parameters
--> $DIR/argument_order.rs:10:36
|
LL | struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
| ---------------------^----------------------^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T, U, const N: usize, const M: usize>`
error[E0747]: lifetime provided when a type was expected
--> $DIR/argument_order.rs:18:23
|
LL | let _: AlsoBad<7, 'static, u32, 'static, 17, u16>;
| ^^^^^^^
|
= note: lifetime arguments must be provided before type arguments
= help: reorder the arguments: lifetimes, then types, then consts: `<'a, 'b, T, U, N, M>`
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0747`.

5
src/test/ui/const-generics/argument_order.rs
View File

@ -1,15 +1,10 @@
// revisions: full min
#![cfg_attr(full, feature(const_generics_defaults))]
struct Bad<const N: usize, T> {
//[min]~^ ERROR type parameters must be declared prior to const parameters
arr: [u8; { N }],
another: T,
}
struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
//~^ ERROR lifetime parameters must be declared prior
//[min]~^^ ERROR type parameters must be declared prior to const parameters
a: &'a T,
b: &'b U,
}

4
src/test/ui/const-generics/argument_order.full.stderr → src/test/ui/const-generics/argument_order.stderr
View File

@ -1,11 +1,11 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/argument_order.rs:10:32
--> $DIR/argument_order.rs:6:32
|
LL | struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
| -----------------^^-----^^-------------------- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, const N: usize, T, const M: usize, U>`
error[E0747]: lifetime provided when a type was expected
--> $DIR/argument_order.rs:18:23
--> $DIR/argument_order.rs:13:23
|
LL | let _: AlsoBad<7, 'static, u32, 'static, 17, u16>;
| ^^^^^^^

3
src/test/ui/const-generics/const-arg-type-arg-misordered.stderr
View File

@ -3,9 +3,6 @@ error[E0747]: constant provided when a type was expected
|
LL | fn foo<const N: usize>() -> Array<N, ()> {
| ^
|
= note: type arguments must be provided before constant arguments
= help: reorder the arguments: types, then consts: `<T, N>`
error: aborting due to previous error

14
src/test/ui/const-generics/const-param-before-other-params.min.stderr
View File

@ -1,14 +0,0 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/const-param-before-other-params.rs:5:21
|
LL | fn bar<const X: u8, 'a>(_: &'a ()) {
| --------------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, const X: u8>`
error: type parameters must be declared prior to const parameters
--> $DIR/const-param-before-other-params.rs:9:21
|
LL | fn foo<const X: u8, T>(_: &T) {}
| --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: u8>`
error: aborting due to 2 previous errors

5
src/test/ui/const-generics/const-param-before-other-params.rs
View File

@ -1,12 +1,7 @@
// revisions: full min
#![cfg_attr(full, feature(const_generics_defaults))]
#![cfg_attr(full, allow(incomplete_features))]
fn bar<const X: u8, 'a>(_: &'a ()) {
//~^ ERROR lifetime parameters must be declared prior to const parameters
}
fn foo<const X: u8, T>(_: &T) {}
//[min]~^ ERROR type parameters must be declared prior to const parameters
fn main() {}

2
src/test/ui/const-generics/const-param-before-other-params.full.stderr → src/test/ui/const-generics/const-param-before-other-params.stderr
View File

@ -1,5 +1,5 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/const-param-before-other-params.rs:5:21
--> $DIR/const-param-before-other-params.rs:1:21
|
LL | fn bar<const X: u8, 'a>(_: &'a ()) {
| --------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const X: u8>`

2
src/test/ui/const-generics/defaults/auxiliary/const_defaulty.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
pub struct Defaulted<const N: usize=3>;
impl Defaulted {
pub fn new() -> Self {

4
src/test/ui/const-generics/defaults/complex-generic-default-expr.min.stderr
View File

@ -1,5 +1,5 @@
error: generic parameters may not be used in const operations
--> $DIR/complex-generic-default-expr.rs:7:47
--> $DIR/complex-generic-default-expr.rs:6:47
|
LL | struct Foo<const N: usize, const M: usize = { N + 1 }>;
| ^ cannot perform const operation using `N`
@ -8,7 +8,7 @@ LL | struct Foo<const N: usize, const M: usize = { N + 1 }>;
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/complex-generic-default-expr.rs:10:62
--> $DIR/complex-generic-default-expr.rs:9:62
|
LL | struct Bar<T, const TYPE_SIZE: usize = { std::mem::size_of::<T>() }>(T);
| ^ cannot perform const operation using `T`

3
src/test/ui/const-generics/defaults/complex-generic-default-expr.rs
View File

@ -1,8 +1,7 @@
// revisions: full min
//[full] check-pass
#![cfg_attr(full, feature(generic_const_exprs))]
#![feature(const_generics_defaults)]
#![allow(incomplete_features)]
#![cfg_attr(full, allow(incomplete_features))]
struct Foo<const N: usize, const M: usize = { N + 1 }>;
//[min]~^ ERROR generic parameters may not be used in const operations

6
src/test/ui/const-generics/defaults/complex-unord-param.rs
View File

@ -1,12 +1,8 @@
// [full] run-pass
// revisions: full min
// run-pass
// Checks a complicated usage of unordered params
#![cfg_attr(full, feature(const_generics_defaults))]
#![cfg_attr(full, allow(incomplete_features))]
#![allow(dead_code)]
struct NestedArrays<'a, const N: usize, A: 'a, const M: usize, T:'a =u32> {
//[min]~^ ERROR type parameters must be declared prior to const parameters
args: &'a [&'a [T; M]; N],
specifier: A,
}

2
src/test/ui/const-generics/defaults/const-default.rs
View File

@ -1,6 +1,4 @@
// run-pass
#![feature(const_generics_defaults)]
pub struct ConstDefault<const N: usize = 3>;
impl<const N: usize> ConstDefault<N> {

1
src/test/ui/const-generics/defaults/const-param-as-default-value.rs
View File

@ -1,5 +1,4 @@
// run-pass
#![feature(const_generics_defaults)]
struct Foo<const N: usize, const M: usize = N>([u8; N], [u8; M]);
fn foo<const N: usize>() -> Foo<N> {

1
src/test/ui/const-generics/defaults/const-param-in-ty-defaults.rs
View File

@ -1,5 +1,4 @@
// run-pass
#![feature(const_generics_defaults)]
struct Foo<const N: usize, T = [u8; N]>(T);
impl<const N: usize> Foo<N> {

1
src/test/ui/const-generics/defaults/default-annotation.rs
View File

@ -1,6 +1,5 @@
// run-pass
#![feature(staged_api)]
#![feature(const_generics_defaults)]
#![allow(incomplete_features)]
// FIXME(const_generics_defaults): It seems like we aren't testing the right thing here,
// I would assume that we want the attributes to apply to the const parameter defaults

2
src/test/ui/const-generics/defaults/default-const-param-cannot-reference-self.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
struct Struct<const N: usize = { Self; 10 }>;
//~^ ERROR generic parameters cannot use `Self` in their defaults [E0735]

6
src/test/ui/const-generics/defaults/default-const-param-cannot-reference-self.stderr
View File

@ -1,17 +1,17 @@
error[E0735]: generic parameters cannot use `Self` in their defaults
--> $DIR/default-const-param-cannot-reference-self.rs:3:34
--> $DIR/default-const-param-cannot-reference-self.rs:1:34
|
LL | struct Struct<const N: usize = { Self; 10 }>;
| ^^^^ `Self` in generic parameter default
error[E0735]: generic parameters cannot use `Self` in their defaults
--> $DIR/default-const-param-cannot-reference-self.rs:6:30
--> $DIR/default-const-param-cannot-reference-self.rs:4:30
|
LL | enum Enum<const N: usize = { Self; 10 }> { }
| ^^^^ `Self` in generic parameter default
error[E0735]: generic parameters cannot use `Self` in their defaults
--> $DIR/default-const-param-cannot-reference-self.rs:9:32
--> $DIR/default-const-param-cannot-reference-self.rs:7:32
|
LL | union Union<const N: usize = { Self; 10 }> { not_empty: () }
| ^^^^ `Self` in generic parameter default

2
src/test/ui/const-generics/defaults/default-on-impl.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
struct Foo<const N: usize>;
impl<const N: usize = 1> Foo<N> {}

2
src/test/ui/const-generics/defaults/default-on-impl.stderr
View File

@ -1,5 +1,5 @@
error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
--> $DIR/default-on-impl.rs:5:12
--> $DIR/default-on-impl.rs:3:12
|
LL | impl<const N: usize = 1> Foo<N> {}
| ^

1
src/test/ui/const-generics/defaults/default-param-wf-concrete.rs
View File

@ -1,4 +1,3 @@
#![feature(const_generics_defaults)]
struct Foo<const N: u8 = { 255 + 1 }>;
//~^ ERROR evaluation of constant value failed
fn main() {}

2
src/test/ui/const-generics/defaults/default-param-wf-concrete.stderr
View File

@ -1,5 +1,5 @@
error[E0080]: evaluation of constant value failed
--> $DIR/default-param-wf-concrete.rs:2:28
--> $DIR/default-param-wf-concrete.rs:1:28
|
LL | struct Foo<const N: u8 = { 255 + 1 }>;
| ^^^^^^^ attempt to compute `u8::MAX + 1_u8`, which would overflow

2
src/test/ui/const-generics/defaults/doesnt_infer.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
// test that defaulted const params are not used to help type inference
struct Foo<const N: u32 = 2>;

2
src/test/ui/const-generics/defaults/doesnt_infer.stderr
View File

@ -1,5 +1,5 @@
error[E0282]: type annotations needed for `Foo<{_: u32}>`
--> $DIR/doesnt_infer.rs:13:15
--> $DIR/doesnt_infer.rs:11:15
|
LL | let foo = Foo::foo();
| --- ^^^^^^^^ cannot infer the value of const parameter `N`

2
src/test/ui/const-generics/defaults/external.rs
View File

@ -1,7 +1,5 @@
// aux-build:const_defaulty.rs
// check-pass
#![feature(const_generics_defaults)]
extern crate const_defaulty;
use const_defaulty::Defaulted;

2
src/test/ui/const-generics/defaults/forward-declared.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
struct Foo<const N: usize = M, const M: usize = 10>;
//~^ ERROR generic parameters with a default cannot use forward declared identifiers

8
src/test/ui/const-generics/defaults/forward-declared.stderr
View File

@ -1,23 +1,23 @@
error[E0128]: generic parameters with a default cannot use forward declared identifiers
--> $DIR/forward-declared.rs:3:29
--> $DIR/forward-declared.rs:1:29
|
LL | struct Foo<const N: usize = M, const M: usize = 10>;
| ^ defaulted generic parameters cannot be forward declared
error[E0128]: generic parameters with a default cannot use forward declared identifiers
--> $DIR/forward-declared.rs:6:27
--> $DIR/forward-declared.rs:4:27
|
LL | enum Bar<const N: usize = M, const M: usize = 10> {}
| ^ defaulted generic parameters cannot be forward declared
error[E0128]: generic parameters with a default cannot use forward declared identifiers
--> $DIR/forward-declared.rs:9:30
--> $DIR/forward-declared.rs:7:30
|
LL | struct Foo2<const N: usize = N>;
| ^ defaulted generic parameters cannot be forward declared
error[E0128]: generic parameters with a default cannot use forward declared identifiers
--> $DIR/forward-declared.rs:12:28
--> $DIR/forward-declared.rs:10:28
|
LL | enum Bar2<const N: usize = N> {}
| ^ defaulted generic parameters cannot be forward declared

2
src/test/ui/const-generics/defaults/generic-expr-default-concrete.rs
View File

@ -1,4 +1,4 @@
#![feature(generic_const_exprs, const_generics_defaults)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
struct Foo<const N: usize, const M: usize = { N + 1 }>;

2
src/test/ui/const-generics/defaults/generic-expr-default-mismatched-types.rs
View File

@ -1,4 +1,4 @@
#![feature(generic_const_exprs, const_generics_defaults)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
struct Foo<const N: usize, const M: usize = { N + 1 }>;

2
src/test/ui/const-generics/defaults/generic-expr-default.rs
View File

@ -1,4 +1,4 @@
#![feature(generic_const_exprs, const_generics_defaults)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
pub struct Foo<const N: usize, const M: usize = { N + 1 }>;

14
src/test/ui/const-generics/defaults/intermixed-lifetime.min.stderr
View File

@ -1,14 +0,0 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/intermixed-lifetime.rs:5:28
|
LL | struct Foo<const N: usize, 'a, T = u32>(&'a (), T);
| -----------------^^---------- help: reorder the parameters: lifetimes, then consts and types: `<'a, const N: usize, T = u32>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/intermixed-lifetime.rs:8:37
|
LL | struct Bar<const N: usize, T = u32, 'a>(&'a (), T);
| --------------------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const N: usize, T = u32>`
error: aborting due to 2 previous errors

2
src/test/ui/const-generics/defaults/intermixed-lifetime.rs
View File

@ -1,6 +1,4 @@
// Checks that lifetimes cannot be interspersed between consts and types.
// revisions: full min
#![feature(const_generics_defaults)]
struct Foo<const N: usize, 'a, T = u32>(&'a (), T);
//~^ Error lifetime parameters must be declared prior to const parameters

4
src/test/ui/const-generics/defaults/intermixed-lifetime.full.stderr → src/test/ui/const-generics/defaults/intermixed-lifetime.stderr
View File

@ -1,11 +1,11 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/intermixed-lifetime.rs:5:28
--> $DIR/intermixed-lifetime.rs:3:28
|
LL | struct Foo<const N: usize, 'a, T = u32>(&'a (), T);
| -----------------^^---------- help: reorder the parameters: lifetimes, then consts and types: `<'a, const N: usize, T = u32>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/intermixed-lifetime.rs:8:37
--> $DIR/intermixed-lifetime.rs:6:37
|
LL | struct Bar<const N: usize, T = u32, 'a>(&'a (), T);
| --------------------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const N: usize, T = u32>`

2
src/test/ui/const-generics/defaults/mismatch.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
pub struct Example<const N: usize=13>;
pub struct Example2<T=u32, const N: usize=13>(T);
pub struct Example3<const N: usize=13, T=u32>(T);

10
src/test/ui/const-generics/defaults/mismatch.stderr
View File

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/mismatch.rs:9:28
--> $DIR/mismatch.rs:7:28
|
LL | let e: Example::<13> = ();
| ------------- ^^ expected struct `Example`, found `()`
@ -10,7 +10,7 @@ LL | let e: Example::<13> = ();
found unit type `()`
error[E0308]: mismatched types
--> $DIR/mismatch.rs:12:34
--> $DIR/mismatch.rs:10:34
|
LL | let e: Example2::<u32, 13> = ();
| ------------------- ^^ expected struct `Example2`, found `()`
@ -21,7 +21,7 @@ LL | let e: Example2::<u32, 13> = ();
found unit type `()`
error[E0308]: mismatched types
--> $DIR/mismatch.rs:15:34
--> $DIR/mismatch.rs:13:34
|
LL | let e: Example3::<13, u32> = ();
| ------------------- ^^ expected struct `Example3`, found `()`
@ -32,7 +32,7 @@ LL | let e: Example3::<13, u32> = ();
found unit type `()`
error[E0308]: mismatched types
--> $DIR/mismatch.rs:18:28
--> $DIR/mismatch.rs:16:28
|
LL | let e: Example3::<7> = ();
| ------------- ^^ expected struct `Example3`, found `()`
@ -43,7 +43,7 @@ LL | let e: Example3::<7> = ();
found unit type `()`
error[E0308]: mismatched types
--> $DIR/mismatch.rs:21:28
--> $DIR/mismatch.rs:19:28
|
LL | let e: Example4::<7> = ();
| ------------- ^^ expected struct `Example4`, found `()`

8
src/test/ui/const-generics/defaults/needs-feature.min.stderr
View File

@ -1,8 +0,0 @@
error: type parameters must be declared prior to const parameters
--> $DIR/needs-feature.rs:7:26
|
LL | struct A<const N: usize, T=u32>(T);
| -----------------^----- help: reorder the parameters: lifetimes, then types, then consts: `<T = u32, const N: usize>`
error: aborting due to previous error

12
src/test/ui/const-generics/defaults/needs-feature.rs
View File

@ -1,12 +0,0 @@
//[full] run-pass
// Verifies that having generic parameters after constants is not permitted without the
// `const_generics_defaults` feature.
// revisions: min full
#![cfg_attr(full, feature(const_generics_defaults))]
struct A<const N: usize, T=u32>(T);
//[min]~^ ERROR type parameters must be declared prior
fn main() {
let _: A<3> = A(0);
}

1
src/test/ui/const-generics/defaults/param-order-err-pretty-prints-default.rs
View File

@ -1,4 +1,3 @@
#![feature(const_generics_defaults)]
struct Foo<const M: usize = 10, 'a>(&'a u32);
//~^ Error lifetime parameters must be declared prior to const parameters

2
src/test/ui/const-generics/defaults/param-order-err-pretty-prints-default.stderr
View File

@ -1,5 +1,5 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/param-order-err-pretty-prints-default.rs:2:33
--> $DIR/param-order-err-pretty-prints-default.rs:1:33
|
LL | struct Foo<const M: usize = 10, 'a>(&'a u32);
| ----------------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const M: usize = 10>`

1
src/test/ui/const-generics/defaults/pretty-printing-ast.rs
View File

@ -3,7 +3,6 @@
// compile-flags: -Z unpretty=expanded
#![crate_type = "lib"]
#![feature(const_generics_defaults)]
trait Foo<const KIND: bool = true> {}

1
src/test/ui/const-generics/defaults/pretty-printing-ast.stdout
View File

@ -5,7 +5,6 @@
// compile-flags: -Z unpretty=expanded
#![crate_type = "lib"]
#![feature(const_generics_defaults)]
#[prelude_import]
use ::std::prelude::rust_2015::*;
#[macro_use]

2
src/test/ui/const-generics/defaults/repr-c-issue-82792.rs
View File

@ -2,8 +2,6 @@
// run-pass
#![feature(const_generics_defaults)]
#[repr(C)]
pub struct Loaf<T: Sized, const N: usize = 1> {
head: [T; N],

2
src/test/ui/const-generics/defaults/rp_impl_trait.rs
View File

@ -1,6 +1,4 @@
// run-pass
#![feature(const_generics_defaults)]
struct Uwu<const N: u32 = 1, const M: u32 = N>;
trait Trait {}

2
src/test/ui/const-generics/defaults/rp_impl_trait_fail.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
struct Uwu<const N: u32 = 1, const M: u32 = N>;
trait Trait {}

6
src/test/ui/const-generics/defaults/rp_impl_trait_fail.stderr
View File

@ -1,5 +1,5 @@
error[E0277]: the trait bound `Uwu<10_u32, 12_u32>: Trait` is not satisfied
--> $DIR/rp_impl_trait_fail.rs:8:14
--> $DIR/rp_impl_trait_fail.rs:6:14
|
LL | fn rawr() -> impl Trait {
| ^^^^^^^^^^ the trait `Trait` is not implemented for `Uwu<10_u32, 12_u32>`
@ -8,7 +8,7 @@ LL | fn rawr() -> impl Trait {
<Uwu<N> as Trait>
error[E0277]: the trait bound `u32: Traitor<N, N>` is not satisfied
--> $DIR/rp_impl_trait_fail.rs:19:26
--> $DIR/rp_impl_trait_fail.rs:17:26
|
LL | fn uwu<const N: u8>() -> impl Traitor<N> {
| ^^^^^^^^^^^^^^^ the trait `Traitor<N, N>` is not implemented for `u32`
@ -17,7 +17,7 @@ LL | fn uwu<const N: u8>() -> impl Traitor<N> {
<u32 as Traitor<N, 2_u8>>
error[E0277]: the trait bound `u64: Traitor<1_u8, 1_u8>` is not satisfied
--> $DIR/rp_impl_trait_fail.rs:24:13
--> $DIR/rp_impl_trait_fail.rs:22:13
|
LL | fn owo() -> impl Traitor {
| ^^^^^^^^^^^^ the trait `Traitor<1_u8, 1_u8>` is not implemented for `u64`

1
src/test/ui/const-generics/defaults/simple-defaults.rs
View File

@ -1,6 +1,5 @@
// run-pass
// Checks that type param defaults are allowed after const params.
#![feature(const_generics_defaults)]
#![allow(dead_code)]
struct FixedOutput<'a, const N: usize, T=u32> {

2
src/test/ui/const-generics/defaults/trait_objects.rs
View File

@ -1,6 +1,4 @@
// run-pass
#![feature(const_generics_defaults)]
trait Trait<const N: u8 = 12> {
fn uwu(&self) -> u8 {
N

2
src/test/ui/const-generics/defaults/trait_objects_fail.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
trait Trait<const N: u8 = 12> {
fn uwu(&self) -> u8 {
N

4
src/test/ui/const-generics/defaults/trait_objects_fail.stderr
View File

@ -1,5 +1,5 @@
error[E0277]: the trait bound `u32: Trait` is not satisfied
--> $DIR/trait_objects_fail.rs:28:9
--> $DIR/trait_objects_fail.rs:26:9
|
LL | foo(&10_u32);
| --- ^^^^^^^ the trait `Trait` is not implemented for `u32`
@ -11,7 +11,7 @@ LL | foo(&10_u32);
= note: required for the cast to the object type `dyn Trait`
error[E0277]: the trait bound `bool: Traitor<{_: u8}, {_: u8}>` is not satisfied
--> $DIR/trait_objects_fail.rs:30:9
--> $DIR/trait_objects_fail.rs:28:9
|
LL | bar(&true);
| --- ^^^^^ the trait `Traitor<{_: u8}, {_: u8}>` is not implemented for `bool`

2
src/test/ui/const-generics/defaults/type-default-const-param-name.rs
View File

@ -1,6 +1,4 @@
// check-pass
#![feature(const_generics_defaults)]
struct N;
struct Foo<const N: usize = 1, T = N>(T);

2
src/test/ui/const-generics/defaults/wfness.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
struct Ooopsies<const N: u8 = { u8::MAX + 1 }>;
//~^ error: evaluation of constant value failed

8
src/test/ui/const-generics/defaults/wfness.stderr
View File

@ -1,11 +1,11 @@
error[E0080]: evaluation of constant value failed
--> $DIR/wfness.rs:3:33
--> $DIR/wfness.rs:1:33
|
LL | struct Ooopsies<const N: u8 = { u8::MAX + 1 }>;
| ^^^^^^^^^^^ attempt to compute `u8::MAX + 1_u8`, which would overflow
error[E0277]: the trait bound `(): Trait<2_u8>` is not satisfied
--> $DIR/wfness.rs:8:47
--> $DIR/wfness.rs:6:47
|
LL | struct WhereClause<const N: u8 = 2> where (): Trait<N>;
| ^^^^^^^^ the trait `Trait<2_u8>` is not implemented for `()`
@ -14,7 +14,7 @@ LL | struct WhereClause<const N: u8 = 2> where (): Trait<N>;
<() as Trait<3_u8>>
error[E0277]: the trait bound `(): Trait<1_u8>` is not satisfied
--> $DIR/wfness.rs:16:13
--> $DIR/wfness.rs:14:13
|
LL | fn foo() -> DependentDefaultWfness {
| ^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait<1_u8>` is not implemented for `()`
@ -22,7 +22,7 @@ LL | fn foo() -> DependentDefaultWfness {
= help: the following implementations were found:
<() as Trait<3_u8>>
note: required by a bound in `WhereClause`
--> $DIR/wfness.rs:8:47
--> $DIR/wfness.rs:6:47
|
LL | struct WhereClause<const N: u8 = 2> where (): Trait<N>;
| ^^^^^^^^ required by this bound in `WhereClause`

2
src/test/ui/const-generics/defaults/wrong-order.rs
View File

@ -1,5 +1,3 @@
#![feature(const_generics_defaults)]
struct A<T = u32, const N: usize> {
//~^ ERROR generic parameters with a default must be trailing
arg: T,

4
src/test/ui/const-generics/defaults/wrong-order.stderr
View File

@ -1,11 +1,11 @@
error: generic parameters with a default must be trailing
--> $DIR/wrong-order.rs:3:10
--> $DIR/wrong-order.rs:1:10
|
LL | struct A<T = u32, const N: usize> {
| ^
error: generic parameters with a default must be trailing
--> $DIR/wrong-order.rs:8:18
--> $DIR/wrong-order.rs:6:18
|
LL | struct Foo<const N: u8 = 3, T>(T);
| ^

2
src/test/ui/const-generics/generic_const_exprs/unused-complex-default-expr.rs
View File

@ -1,5 +1,5 @@
// check-pass
#![feature(generic_const_exprs, const_generics_defaults)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
struct Foo<const N: usize, const M: usize = { N + 1 }>;
struct Bar<const N: usize>(Foo<N, 3>);

2
src/test/ui/const-generics/invalid-enum.rs
View File

@ -1,4 +1,4 @@
#![feature(adt_const_params, const_generics_defaults)]
#![feature(adt_const_params)]
#![allow(incomplete_features)]
#[derive(PartialEq, Eq)]

3
src/test/ui/const-generics/min_const_generics/const_default_first.rs
View File

@ -1,6 +1,5 @@
#![crate_type = "lib"]
#![feature(const_generics_defaults)]
#![allow(incomplete_features, dead_code)]
#![allow(dead_code)]
struct Both<const N: usize=3, T> {
//~^ ERROR: generic parameters with a default must be

2
src/test/ui/const-generics/min_const_generics/const_default_first.stderr
View File

@ -1,5 +1,5 @@
error: generic parameters with a default must be trailing
--> $DIR/const_default_first.rs:5:19
--> $DIR/const_default_first.rs:4:19
|
LL | struct Both<const N: usize=3, T> {
| ^

1
src/test/ui/const-generics/min_const_generics/default_function_param.rs
View File

@ -1,5 +1,4 @@
#![crate_type = "lib"]
#![feature(const_generics_defaults)]
fn foo<const SIZE: usize = 5usize>() {}
//~^ ERROR defaults for const parameters are

2
src/test/ui/const-generics/min_const_generics/default_function_param.stderr
View File

@ -1,5 +1,5 @@
error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
--> $DIR/default_function_param.rs:4:14
--> $DIR/default_function_param.rs:3:14
|
LL | fn foo<const SIZE: usize = 5usize>() {}
| ^^^^

2
src/test/ui/const-generics/min_const_generics/default_trait_param.rs
View File

@ -1,4 +1,4 @@
// check-pass
trait Foo<const KIND: bool = true> {}
//~^ ERROR default values for const generic parameters are experimental
fn main() {}

12
src/test/ui/const-generics/min_const_generics/default_trait_param.stderr
View File

@ -1,12 +0,0 @@
error[E0658]: default values for const generic parameters are experimental
--> $DIR/default_trait_param.rs:1:28
|
LL | trait Foo<const KIND: bool = true> {}
| ^^^^^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics_defaults)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

1
src/test/ui/const-generics/min_const_generics/type_and_const_defaults.rs
View File

@ -1,5 +1,4 @@
// run-pass
#![feature(const_generics_defaults)]
#![allow(dead_code)]
struct Both<T=u32, const N: usize=3> {

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

@ -3,8 +3,6 @@ error: generic parameters with a default must be trailing
|
LL | struct Bar<T = [u8; N], const N: usize>(T);
| ^
|
= note: using type defaults and const parameters in the same parameter list is currently not permitted
error: generic parameters may not be used in const operations
--> $DIR/params-in-ct-in-ty-param-lazy-norm.rs:5:44

7
src/test/ui/const-generics/type-after-const-ok.rs
View File

@ -1,11 +1,6 @@
// [full] run-pass
// revisions: full min
// run-pass
// Verifies that having generic parameters after constants is permitted
#![cfg_attr(full, feature(const_generics_defaults))]
#![cfg_attr(full, allow(incomplete_features))]
#[allow(dead_code)]
struct A<const N: usize, T>(T);
//[min]~^ ERROR type parameters must be declared prior to const parameters
fn main() {}

2
src/test/ui/derives/derive-macro-const-default.rs
View File

@ -1,6 +1,4 @@
// check-pass
#![feature(const_generics_defaults)]
#[derive(Clone, PartialEq, Debug)]
struct Example<T, const N: usize = 1usize>([T; N]);

9
src/test/ui/feature-gates/feature-gate-const_generics_defaults.rs
View File

@ -1,9 +0,0 @@
#[cfg(FALSE)]
struct A<const N: usize = 3>;
//~^ ERROR default values for const generic parameters are experimental
#[cfg(FALSE)]
fn foo<const B: bool = false>() {}
//~^ ERROR default values for const generic parameters are experimental
fn main() {}

21
src/test/ui/feature-gates/feature-gate-const_generics_defaults.stderr
View File

@ -1,21 +0,0 @@
error[E0658]: default values for const generic parameters are experimental
--> $DIR/feature-gate-const_generics_defaults.rs:2:25
|
LL | struct A<const N: usize = 3>;
| ^^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics_defaults)]` to the crate attributes to enable
error[E0658]: default values for const generic parameters are experimental
--> $DIR/feature-gate-const_generics_defaults.rs:6:22
|
LL | fn foo<const B: bool = false>() {}
| ^^^^^^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics_defaults)]` to the crate attributes to enable
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0658`.

3
src/test/ui/generics/issue-59508-1.rs
View File

@ -1,8 +1,7 @@
#![allow(dead_code)]
#![feature(const_generics_defaults)]
// This test checks that generic parameter re-ordering diagnostic suggestions mention that
// consts come after types and lifetimes when the `const_generics_defaults` feature is enabled.
// consts come after types and lifetimes.
// We cannot run rustfix on this test because of the above const generics warning.
struct A;

2
src/test/ui/generics/issue-59508-1.stderr
View File

@ -1,5 +1,5 @@
error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-59508-1.rs:11:25
--> $DIR/issue-59508-1.rs:10:25
|
LL | pub fn do_things<T, 'a, 'b: 'a>() {
| ----^^--^^----- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b: 'a, T>`

2
src/test/ui/generics/issue-59508.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-59508.rs:10:25
|
LL | pub fn do_things<T, 'a, 'b: 'a>() {
| ----^^--^^----- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b: 'a, T>`
| ----^^--^^----- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b: 'a, T>`
error: aborting due to previous error

8
src/test/ui/generics/lifetime-before-type-params.stderr
View File

@ -2,25 +2,25 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/lifetime-before-type-params.rs:2:13
|
LL | fn first<T, 'a, 'b>() {}
| ----^^--^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| ----^^--^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/lifetime-before-type-params.rs:4:18
|
LL | fn second<'a, T, 'b>() {}
| --------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| --------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/lifetime-before-type-params.rs:6:16
|
LL | fn third<T, U, 'a>() {}
| -------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, T, U>`
| -------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, T, U>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/lifetime-before-type-params.rs:8:18
|
LL | fn fourth<'a, T, 'b, U, 'c, V>() {}
| --------^^-----^^---- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, 'c, T, U, V>`
| --------^^-----^^---- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, 'c, T, U, V>`
error: aborting due to 4 previous errors

2
src/test/ui/issues/issue-80512-param-reordering-with-defaults.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-80512-param-reordering-with-defaults.rs:3:18
|
LL | struct S<T = (), 'a>(&'a T);
| ---------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, T = ()>`
| ---------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, T = ()>`
error: aborting due to previous error

3
src/test/ui/missing/missing-items/missing-type-parameter2.rs
View File

@ -1,6 +1,3 @@
#![allow(incomplete_features)]
#![feature(const_generics_defaults)]
struct X<const N: u8>();
impl X<N> {}

16
src/test/ui/missing/missing-items/missing-type-parameter2.stderr
View File

@ -1,5 +1,5 @@
error[E0412]: cannot find type `N` in this scope
--> $DIR/missing-type-parameter2.rs:6:8
--> $DIR/missing-type-parameter2.rs:3:8
|
LL | struct X<const N: u8>();
| ------------------------ similarly named struct `X` defined here
@ -17,7 +17,7 @@ LL | impl<N> X<N> {}
| +++
error[E0412]: cannot find type `N` in this scope
--> $DIR/missing-type-parameter2.rs:9:28
--> $DIR/missing-type-parameter2.rs:6:28
|
LL | impl<T, const A: u8 = 2> X<N> {}
| - ^
@ -34,7 +34,7 @@ LL | impl<T, const A: u8 = 2, N> X<N> {}
| +++
error[E0412]: cannot find type `T` in this scope
--> $DIR/missing-type-parameter2.rs:14:20
--> $DIR/missing-type-parameter2.rs:11:20
|
LL | struct X<const N: u8>();
| ------------------------ similarly named struct `X` defined here
@ -52,7 +52,7 @@ LL | fn foo<T>(_: T) where T: Send {}
| +++
error[E0412]: cannot find type `T` in this scope
--> $DIR/missing-type-parameter2.rs:14:11
--> $DIR/missing-type-parameter2.rs:11:11
|
LL | struct X<const N: u8>();
| ------------------------ similarly named struct `X` defined here
@ -70,7 +70,7 @@ LL | fn foo<T>(_: T) where T: Send {}
| +++
error[E0412]: cannot find type `A` in this scope
--> $DIR/missing-type-parameter2.rs:18:24
--> $DIR/missing-type-parameter2.rs:15:24
|
LL | struct X<const N: u8>();
| ------------------------ similarly named struct `X` defined here
@ -88,7 +88,7 @@ LL | fn bar<const N: u8, A>(_: A) {}
| +++
error[E0747]: unresolved item provided when a constant was expected
--> $DIR/missing-type-parameter2.rs:6:8
--> $DIR/missing-type-parameter2.rs:3:8
|
LL | impl X<N> {}
| ^
@ -99,13 +99,13 @@ LL | impl X<{ N }> {}
| + +
error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
--> $DIR/missing-type-parameter2.rs:9:15
--> $DIR/missing-type-parameter2.rs:6:15
|
LL | impl<T, const A: u8 = 2> X<N> {}
| ^
error[E0747]: unresolved item provided when a constant was expected
--> $DIR/missing-type-parameter2.rs:9:28
--> $DIR/missing-type-parameter2.rs:6:28
|
LL | impl<T, const A: u8 = 2> X<N> {}
| ^

2
src/test/ui/parser/issues/issue-14303-enum.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-14303-enum.rs:1:15
|
LL | enum X<'a, T, 'b> {
| --------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| --------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: aborting due to previous error

2
src/test/ui/parser/issues/issue-14303-fn-def.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-14303-fn-def.rs:1:15
|
LL | fn foo<'a, T, 'b>(x: &'a T) {}
| --------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| --------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: aborting due to previous error

2
src/test/ui/parser/issues/issue-14303-impl.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-14303-impl.rs:3:13
|
LL | impl<'a, T, 'b> X<T> {}
| --------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| --------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: aborting due to previous error

2
src/test/ui/parser/issues/issue-14303-struct.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-14303-struct.rs:1:17
|
LL | struct X<'a, T, 'b> {
| --------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| --------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: aborting due to previous error

2
src/test/ui/parser/issues/issue-14303-trait.stderr
View File

@ -2,7 +2,7 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/issue-14303-trait.rs:1:18
|
LL | trait Foo<'a, T, 'b> {}
| --------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T>`
| --------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, T>`
error: aborting due to previous error

8
src/test/ui/suggestions/suggest-move-lifetimes.stderr
View File

@ -2,25 +2,25 @@ error: lifetime parameters must be declared prior to type parameters
--> $DIR/suggest-move-lifetimes.rs:1:13
|
LL | struct A<T, 'a> {
| ----^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, T>`
| ----^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, T>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/suggest-move-lifetimes.rs:5:13
|
LL | struct B<T, 'a, U> {
| ----^^---- help: reorder the parameters: lifetimes, then types, then consts: `<'a, T, U>`
| ----^^---- help: reorder the parameters: lifetimes, then consts and types: `<'a, T, U>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/suggest-move-lifetimes.rs:10:16
|
LL | struct C<T, U, 'a> {
| -------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, T, U>`
| -------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, T, U>`
error: lifetime parameters must be declared prior to type parameters
--> $DIR/suggest-move-lifetimes.rs:15:16
|
LL | struct D<T, U, 'a, 'b, V, 'c> {
| -------^^--^^-----^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, 'c, T, U, V>`
| -------^^--^^-----^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, 'c, T, U, V>`
error: aborting due to 4 previous errors

1
src/tools/clippy/tests/ui/trailing_empty_array.rs
View File

@ -1,5 +1,4 @@
#![warn(clippy::trailing_empty_array)]
#![feature(const_generics_defaults)]
// Do lint:

22
src/tools/clippy/tests/ui/trailing_empty_array.stderr
View File

@ -1,5 +1,5 @@
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:6:1
--> $DIR/trailing_empty_array.rs:5:1
|
LL | / struct RarelyUseful {
LL | | field: i32,
@ -11,7 +11,7 @@ LL | | }
= help: consider annotating `RarelyUseful` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:11:1
--> $DIR/trailing_empty_array.rs:10:1
|
LL | / struct OnlyField {
LL | | first_and_last: [usize; 0],
@ -21,7 +21,7 @@ LL | | }
= help: consider annotating `OnlyField` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:15:1
--> $DIR/trailing_empty_array.rs:14:1
|
LL | / struct GenericArrayType<T> {
LL | | field: i32,
@ -32,7 +32,7 @@ LL | | }
= help: consider annotating `GenericArrayType` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:21:1
--> $DIR/trailing_empty_array.rs:20:1
|
LL | / struct OnlyAnotherAttribute {
LL | | field: i32,
@ -43,7 +43,7 @@ LL | | }
= help: consider annotating `OnlyAnotherAttribute` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:27:1
--> $DIR/trailing_empty_array.rs:26:1
|
LL | / struct OnlyADeriveAttribute {
LL | | field: i32,
@ -54,7 +54,7 @@ LL | | }
= help: consider annotating `OnlyADeriveAttribute` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:33:1
--> $DIR/trailing_empty_array.rs:32:1
|
LL | / struct ZeroSizedWithConst {
LL | | field: i32,
@ -65,7 +65,7 @@ LL | | }
= help: consider annotating `ZeroSizedWithConst` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:42:1
--> $DIR/trailing_empty_array.rs:41:1
|
LL | / struct ZeroSizedWithConstFunction {
LL | | field: i32,
@ -76,7 +76,7 @@ LL | | }
= help: consider annotating `ZeroSizedWithConstFunction` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:50:1
--> $DIR/trailing_empty_array.rs:49:1
|
LL | / struct ZeroSizedWithConstFunction2 {
LL | | field: i32,
@ -87,7 +87,7 @@ LL | | }
= help: consider annotating `ZeroSizedWithConstFunction2` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:55:1
--> $DIR/trailing_empty_array.rs:54:1
|
LL | struct ZeroSizedArrayWrapper([usize; 0]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -95,7 +95,7 @@ LL | struct ZeroSizedArrayWrapper([usize; 0]);
= help: consider annotating `ZeroSizedArrayWrapper` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:57:1
--> $DIR/trailing_empty_array.rs:56:1
|
LL | struct TupleStruct(i32, [usize; 0]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -103,7 +103,7 @@ LL | struct TupleStruct(i32, [usize; 0]);
= help: consider annotating `TupleStruct` with `#[repr(C)]` or another `repr` attribute
error: trailing zero-sized array in a struct which is not marked with a `repr` attribute
--> $DIR/trailing_empty_array.rs:59:1
--> $DIR/trailing_empty_array.rs:58:1
|
LL | / struct LotsOfFields {
LL | | f1: u32,