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

feature(const_generics) -> feature(const_param_types)

Browse Source
This commit is contained in:
lcnr 2021-08-27 18:04:57 +02:00
parent c0e853f274
commit 0c28e028b6
574 changed files with 849 additions and 4305 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -332,7 +332,7 @@ pub type GenericBounds = Vec<GenericBound>;
pub enum ParamKindOrd {
Lifetime,
Type,
// `unordered` is only `true` if `sess.has_features().const_generics`
// `unordered` is only `true` if `sess.has_features().const_generics_defaults`
// is active. Specifically, if it's only `min_const_generics`, it will still require
// ordering consts after types.
Const { unordered: bool },

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

@ -687,7 +687,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
gate_all!(trait_alias, "trait aliases are experimental");
gate_all!(associated_type_bounds, "associated type bounds are unstable");
gate_all!(crate_visibility_modifier, "`crate` visibility modifier is experimental");
gate_all!(const_generics, "const generics are unstable");
gate_all!(decl_macro, "`macro` is experimental");
gate_all!(box_patterns, "box pattern syntax is experimental");
gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");

2
compiler/rustc_error_codes/src/error_codes/E0671.md
View File

@ -4,8 +4,6 @@ Const parameters cannot depend on type parameters.
The following is therefore invalid:
```compile_fail,E0770
#![feature(const_generics)]
fn const_id<T, const N: T>() -> T { // error
N
}

4
compiler/rustc_error_codes/src/error_codes/E0741.md
View File

@ -3,7 +3,7 @@ A non-structural-match type was used as the type of a const generic parameter.
Erroneous code example:
```compile_fail,E0741
#![feature(const_generics)]
#![feature(const_param_types)]
struct A;
@ -16,7 +16,7 @@ may be used as the types of const generic parameters.
To fix the previous code example, we derive `PartialEq` and `Eq`:
```
#![feature(const_generics)]
#![feature(const_param_types)]
#[derive(PartialEq, Eq)] // We derive both traits here.
struct A;

1
compiler/rustc_error_codes/src/error_codes/E0770.md
View File

@ -3,7 +3,6 @@ The type of a const parameter references other generic parameters.
Erroneous code example:
```compile_fail,E0770
#![feature(const_generics)]
fn foo<T, const N: T>() {} // error!
```

4
compiler/rustc_error_codes/src/error_codes/E0771.md
View File

@ -4,7 +4,7 @@ allowed.
Erroneous code example:
```compile_fail,E0771
#![feature(const_generics)]
#![feature(const_param_types)]
fn function_with_str<'a, const STRING: &'a str>() {} // error!
```
@ -13,7 +13,7 @@ To fix this issue, the lifetime in the const generic need to be changed to
`'static`:
```
#![feature(const_generics)]
#![feature(const_param_types)]
fn function_with_str<const STRING: &'static str>() {} // ok!
```

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

@ -273,7 +273,7 @@ declare_features! (
/// Allows patterns with concurrent by-move and by-ref bindings.
/// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
(accepted, move_ref_pattern, "1.49.0", Some(68354), None),
/// The smallest useful subset of `const_generics`.
/// The smallest useful subset of const generics.
(accepted, min_const_generics, "1.51.0", Some(74878), None),
/// The `unsafe_op_in_unsafe_fn` lint (allowed by default): no longer treat an unsafe function as an unsafe block.
(accepted, unsafe_block_in_unsafe_fn, "1.52.0", Some(71668), None),

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

@ -71,7 +71,7 @@ macro_rules! declare_features {
}
pub fn unordered_const_ty_params(&self) -> bool {
self.const_generics || self.const_generics_defaults
self.const_generics_defaults
}
/// Some features are known to be incomplete and using them is likely to have
@ -453,9 +453,6 @@ declare_features! (
/// Allows using `#[ffi_returns_twice]` on foreign functions.
(active, ffi_returns_twice, "1.34.0", Some(58314), None),
/// Allows const generic types (e.g. `struct Foo<const N: usize>(...);`).
(incomplete, const_generics, "1.34.0", Some(44580), None),
/// Allows using `#[optimize(X)]`.
(active, optimize_attribute, "1.34.0", Some(54882), None),
@ -676,6 +673,9 @@ declare_features! (
/// Allows non-trivial generic constants which have to have wfness manually propagated to callers
(incomplete, generic_const_exprs, "1.56.0", Some(76560), None),
/// Allows additional const parameter types, such as `&'static str` or user defined types
(incomplete, const_param_types, "1.56.0", Some(44580), None),
// -------------------------------------------------------------------------
// feature-group-end: actual feature gates
// -------------------------------------------------------------------------

3
compiler/rustc_feature/src/removed.rs
View File

@ -102,6 +102,9 @@ declare_features! (
(removed, extern_in_paths, "1.33.0", Some(55600), None,
Some("subsumed by `::foo::bar` paths")),
(removed, quote, "1.33.0", Some(29601), None, None),
/// Allows const generic types (e.g. `struct Foo<const N: usize>(...);`).
(removed, const_generics, "1.34.0", Some(44580), None,
Some("removed in favor of `#![feature(const_param_types]` and `#![feature(generic_const_exprs)]`")),
/// Allows `[x; N]` where `x` is a constant (RFC 2203).
(removed, const_in_array_repeat_expressions, "1.37.0", Some(49147), None,
Some("removed due to causing promotable bugs")),

2
compiler/rustc_infer/src/infer/combine.rs
View File

@ -202,7 +202,7 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
/// A good example of this is the following:
///
/// ```rust
/// #![feature(const_generics)]
/// #![feature(generic_const_exprs)]
///
/// fn bind<const N: usize>(value: [u8; N]) -> [u8; 3 + 4] {
/// todo!()

2
compiler/rustc_lint/src/builtin.rs
View File

@ -2340,7 +2340,7 @@ declare_lint! {
/// ### Example
///
/// ```rust
/// #![feature(const_generics)]
/// #![feature(generic_const_exprs)]
/// ```
///
/// {{produces}}

4
compiler/rustc_middle/src/ty/context.rs
View File

@ -1420,8 +1420,8 @@ impl<'tcx> TyCtxt<'tcx> {
#[inline]
pub fn lazy_normalization(self) -> bool {
let features = self.features();
// Note: We do not enable lazy normalization for `min_const_generics`.
features.const_generics || features.generic_const_exprs
// Note: We only use lazy normalization for generic const expressions.
features.generic_const_exprs
}
#[inline]

3
compiler/rustc_resolve/src/diagnostics.rs
View File

@ -506,8 +506,7 @@ impl<'a> Resolver<'a> {
if self.session.is_nightly_build() {
err.help(
"use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` \
to allow generic const expressions",
"use `#![feature(generic_const_exprs)]` to allow generic const expressions",
);
}

4
compiler/rustc_resolve/src/late/diagnostics.rs
View File

@ -2245,7 +2245,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
}
/// Non-static lifetimes are prohibited in anonymous constants under `min_const_generics`.
/// This function will emit an error if `const_generics` is not enabled, the body identified by
/// This function will emit an error if `generic_const_exprs` is not enabled, the body identified by
/// `body_id` is an anonymous constant and `lifetime_ref` is non-static.
crate fn maybe_emit_forbidden_non_static_lifetime_error(
&self,
@ -2264,7 +2264,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
if !self.tcx.lazy_normalization() && is_anon_const && !is_allowed_lifetime {
feature_err(
&self.tcx.sess.parse_sess,
sym::const_generics,
sym::generic_const_exprs,
lifetime_ref.span,
"a non-static lifetime is not allowed in a `const`",
)

2
compiler/rustc_resolve/src/late/lifetimes.rs
View File

@ -2301,7 +2301,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
match *scope {
Scope::Body { id, s } => {
// Non-static lifetimes are prohibited in anonymous constants without
// `const_generics`.
// `generic_const_exprs`.
self.maybe_emit_forbidden_non_static_lifetime_error(id, lifetime_ref);
outermost_body = Some(id);

6
compiler/rustc_resolve/src/lib.rs
View File

@ -2734,8 +2734,7 @@ impl<'a> Resolver<'a> {
ConstantItemRibKind(trivial, _) => {
let features = self.session.features_untracked();
// HACK(min_const_generics): We currently only allow `N` or `{ N }`.
if !(trivial || features.const_generics || features.generic_const_exprs)
{
if !(trivial || features.generic_const_exprs) {
// HACK(min_const_generics): If we encounter `Self` in an anonymous constant
// we can't easily tell if it's generic at this stage, so we instead remember
// this and then enforce the self type to be concrete later on.
@ -2807,8 +2806,7 @@ impl<'a> Resolver<'a> {
ConstantItemRibKind(trivial, _) => {
let features = self.session.features_untracked();
// HACK(min_const_generics): We currently only allow `N` or `{ N }`.
if !(trivial || features.const_generics || features.generic_const_exprs)
{
if !(trivial || features.generic_const_exprs) {
if record_used {
self.report_error(
span,

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

@ -451,6 +451,7 @@ symbols! {
const_mut_refs,
const_panic,
const_panic_fmt,
const_param_types,
const_precise_live_drops,
const_ptr,
const_raw_ptr_deref,

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

@ -290,7 +290,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
let err_ty_str;
let mut is_ptr = true;
let err = if tcx.features().const_generics {
let err = if tcx.features().const_param_types {
match ty.peel_refs().kind() {
ty::FnPtr(_) => Some("function pointers"),
ty::RawPtr(_) => Some("raw pointers"),
@ -328,7 +328,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
err.note("the only supported types are integers, `bool` and `char`");
if tcx.sess.is_nightly_build() {
err.help(
"more complex types are supported with `#![feature(const_generics)]`",
"more complex types are supported with `#![feature(const_param_types)]`",
);
}
err.emit()

2
compiler/rustc_typeck/src/collect.rs
View File

@ -1489,7 +1489,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
}
// HACK(eddyb) this provides the correct generics when
// `feature(const_generics)` is enabled, so that const expressions
// `feature(generic_const_expressions)` is enabled, so that const expressions
// used with const generics, e.g. `Foo<{N+1}>`, can work at all.
//
// Note that we do not supply the parent generics when using

4
src/test/debuginfo/function-names.rs
View File

@ -82,8 +82,8 @@
#![allow(unused_variables)]
#![feature(omit_gdb_pretty_printer_section)]
#![omit_gdb_pretty_printer_section]
#![feature(const_generics, generators, generator_trait)]
#![allow(incomplete_features)] // for const_generics
#![feature(const_param_types, generators, generator_trait)]
#![allow(incomplete_features)]
use Mod1::TestTrait2;
use std::ops::Generator;

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

@ -1,5 +1,5 @@
// revisions: cfail
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs, const_param_types)]
#![allow(incomplete_features)]
// regression test for #77650
fn c<T, const N: std::num::NonZeroUsize>()

35
src/test/incremental/const-generics/hash-tyvid-regression-1.stderr
View File

@ -1,35 +0,0 @@
error[E0277]: the trait bound `[T; _]: From<()>` is not satisfied
--> $DIR/hash-tyvid-regression-1.rs:9:5
|
LL | <[T; N.get()]>::try_from(())
| ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<()>` is not implemented for `[T; _]`
|
= note: required because of the requirements on the impl of `Into<[T; _]>` for `()`
= note: required because of the requirements on the impl of `TryFrom<()>` for `[T; _]`
note: required by `try_from`
--> $SRC_DIR/core/src/convert/mod.rs:LL:COL
|
LL | fn try_from(value: T) -> Result<Self, Self::Error>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0308]: mismatched types
--> $DIR/hash-tyvid-regression-1.rs:9:5
|
LL | <[T; N.get()]>::try_from(())
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found enum `Result`
|
= note: expected unit type `()`
found enum `Result<[T; _], Infallible>`
help: consider using a semicolon here
|
LL | <[T; N.get()]>::try_from(());
| +
help: try adding a return type
|
LL | -> Result<[T; _], Infallible> where
| +++++++++++++++++++++++++++++
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0277, E0308.
For more information about an error, try `rustc --explain E0277`.

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

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

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

@ -1,11 +0,0 @@
error[E0277]: can't compare `[B; _]` with `&&[A]`
--> $DIR/hash-tyvid-regression-2.rs:12:16
|
LL | self.0 == other
| ^^ no implementation for `[B; _] == &&[A]`
|
= help: the trait `PartialEq<&&[A]>` is not implemented for `[B; _]`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

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

@ -1,5 +1,5 @@
// revisions: cfail
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// regression test for #79251
struct Node<const D: usize>

12
src/test/incremental/const-generics/hash-tyvid-regression-3.stderr
View File

@ -1,12 +0,0 @@
error[E0599]: no method named `some_function` found for struct `SmallVec` in the current scope
--> $DIR/hash-tyvid-regression-3.rs:17:19
|
LL | node.keys.some_function();
| ^^^^^^^^^^^^^ method not found in `SmallVec<{ D * 2 }>`
...
LL | struct SmallVec<const D: usize> {}
| ------------------------------- method `some_function` not found for this
error: aborting due to previous error
For more information about this error, try `rustc --explain E0599`.

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

@ -1,5 +1,5 @@
// revisions: cfail
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// regression test for #79251
#[derive(Debug)]

12
src/test/incremental/const-generics/hash-tyvid-regression-4.stderr
View File

@ -1,12 +0,0 @@
error[E0599]: no method named `push` found for struct `SmallVec` in the current scope
--> $DIR/hash-tyvid-regression-4.rs:23:19
|
LL | node.keys.push(k);
| ^^^^ method not found in `SmallVec<_, { D * 2 }>`
...
LL | struct SmallVec<T, const D: usize> {
| ---------------------------------- method `push` not found for this
error: aborting due to previous error
For more information about this error, try `rustc --explain E0599`.

2
src/test/incremental/const-generics/issue-61338.rs
View File

@ -1,7 +1,5 @@
// revisions:rpass1
#![feature(const_generics)]
struct Struct<T>(T);
impl<T, const N: usize> Struct<[T; N]> {

2
src/test/incremental/const-generics/issue-61516.rs
View File

@ -1,7 +1,5 @@
// revisions:rpass1
#![feature(const_generics)]
struct FakeArray<T, const N: usize>(T);
impl<T, const N: usize> FakeArray<T, N> {

3
src/test/incremental/const-generics/issue-62536.rs
View File

@ -1,7 +1,4 @@
// revisions:cfail1
#![feature(const_generics)]
//[cfail1]~^ WARN the feature `const_generics` is incomplete
struct S<T, const N: usize>([T; N]);
fn f<T, const N: usize>(x: T) -> S<T, {N}> { panic!() }

2
src/test/incremental/const-generics/issue-64087.rs
View File

@ -1,6 +1,4 @@
// revisions:cfail1
#![feature(const_generics)]
//[cfail1]~^ WARN the feature `const_generics` is incomplete
fn combinator<T, const S: usize>() -> [T; S] {}
//[cfail1]~^ ERROR mismatched types

2
src/test/incremental/const-generics/issue-65623.rs
View File

@ -1,6 +1,4 @@
// revisions:rpass1
#![feature(const_generics)]
pub struct Foo<T, const N: usize>([T; 0]);
impl<T, const N: usize> Foo<T, {N}> {

4
src/test/incremental/const-generics/issue-68477.rs
View File

@ -1,6 +1,8 @@
// edition:2018
// revisions:rpass1
#![feature(const_generics)]
// Needed to supply generic arguments to the anon const in `[(); FOO]`.
#![feature(generic_const_exprs)]
const FOO: usize = 1;

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-77708-1.rs
View File

@ -1,5 +1,5 @@
// revisions: cfail
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features, unused_braces)]
trait Delegates<T> {}

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-77708-2.rs
View File

@ -1,5 +1,5 @@
// revisions: rpass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
struct Z;

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-77708-3.rs
View File

@ -1,5 +1,5 @@
// revisions: rpass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs, const_param_types)]
#![allow(incomplete_features)]
use std::{convert::TryFrom, num::NonZeroUsize};

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-82034.rs
View File

@ -1,5 +1,5 @@
// revisions: rpass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
pub trait IsTrue {}
pub trait IsFalse {}

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-85031-1.rs
View File

@ -1,5 +1,5 @@
// revisions: rpass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
pub struct Ref<'a, const NUM: usize>(&'a i32);

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-85031-2.rs
View File

@ -1,6 +1,6 @@
// revisions: cfail
#![allow(incomplete_features)]
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
pub struct Ref<'a>(&'a i32);

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-85031-3.rs
View File

@ -1,5 +1,5 @@
// revisions: rpass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
fn test<const SIZE: usize>() {}

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-86953.rs
View File

@ -1,5 +1,5 @@
// revisions: rpass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
struct Foo;

2
src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-88022.rs
View File

@ -1,5 +1,5 @@
// revisions: cfail
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features, unused_braces)]
struct Buffer<T, const S: usize>

1
src/test/rustdoc/const-generics/add-impl.rs
View File

@ -1,4 +1,3 @@
#![feature(const_generics)]
#![crate_name = "foo"]
use std::ops::Add;

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

@ -1,5 +1,4 @@
#![crate_name = "foo"]
#![feature(const_generics)]
pub trait Array {
type Item;

2
src/test/rustdoc/const-generics/const-impl.rs
View File

@ -1,4 +1,4 @@
#![feature(const_generics)]
#![feature(const_param_types)]
#![crate_name = "foo"]

2
src/test/rustdoc/const-generics/const-evaluatable-checked.rs → src/test/rustdoc/const-generics/generic_const_exprs.rs
View File

@ -1,5 +1,5 @@
#![crate_name = "foo"]
#![feature(generic_const_exprs, const_generics)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// make sure that `ConstEvaluatable` predicates dont cause rustdoc to ICE #77647
// @has foo/struct.Ice.html '//pre[@class="rust struct"]' \

2
src/test/rustdoc/const-generics/lazy_normalization_consts/const-equate-pred.rs
View File

@ -1,5 +1,5 @@
#![crate_name = "foo"]
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// Checking if `Send` is implemented for `Hasher` requires us to evaluate a `ConstEquate` predicate,

3
src/test/ui/array-slice-vec/match_arr_unknown_len.rs
View File

@ -1,6 +1,3 @@
#![feature(const_generics)]
//~^ WARN the feature `const_generics` is incomplete
fn is_123<const N: usize>(x: [u32; N]) -> bool {
match x {
[1, 2] => true, //~ ERROR mismatched types

13
src/test/ui/array-slice-vec/match_arr_unknown_len.stderr
View File

@ -1,14 +1,5 @@
warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/match_arr_unknown_len.rs:1:12
|
LL | #![feature(const_generics)]
| ^^^^^^^^^^^^^^
|
= note: `#[warn(incomplete_features)]` on by default
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
error[E0308]: mismatched types
--> $DIR/match_arr_unknown_len.rs:6:9
--> $DIR/match_arr_unknown_len.rs:3:9
|
LL | [1, 2] => true,
| ^^^^^^ expected `2_usize`, found `N`
@ -16,6 +7,6 @@ LL | [1, 2] => true,
= note: expected array `[u32; 2]`
found array `[u32; N]`
error: aborting due to previous error; 1 warning emitted
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

2
src/test/ui/associated-consts/associated-const-type-parameter-arrays.stderr
View File

@ -5,7 +5,7 @@ LL | let _array: [u32; <A as Foo>::Y];
| ^ cannot perform const operation using `A`
|
= note: type parameters may not be used in const expressions
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: aborting due to previous error

2
src/test/ui/associated-item/associated-item-duplicate-bounds.stderr
View File

@ -5,7 +5,7 @@ LL | links: [u32; A::LINKS], // Shouldn't suggest bounds already there.
| ^^^^^^^^ cannot perform const operation using `A`
|
= note: type parameters may not be used in const expressions
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: aborting due to previous error

2
src/test/ui/async-await/issues/issue-78654.rs
View File

@ -1,7 +1,7 @@
// edition:2018
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, feature(const_param_types))]
#![cfg_attr(full, allow(incomplete_features))]
struct Foo;

9
src/test/ui/binding/const-param.min.stderr
View File

@ -1,9 +0,0 @@
error[E0158]: const parameters cannot be referenced in patterns
--> $DIR/const-param.rs:8:9
|
LL | N => {}
| ^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0158`.

3
src/test/ui/binding/const-param.rs
View File

@ -1,7 +1,4 @@
// Identifier pattern referring to a const generic parameter is an error (issue #68853).
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
fn check<const N: usize>() {
match 1 {

2
src/test/ui/binding/const-param.full.stderr → src/test/ui/binding/const-param.stderr
View File

@ -1,5 +1,5 @@
error[E0158]: const parameters cannot be referenced in patterns
--> $DIR/const-param.rs:8:9
--> $DIR/const-param.rs:5:9
|
LL | N => {}
| ^

4
src/test/ui/const-generics/apit-with-const-param.rs
View File

@ -1,8 +1,4 @@
// check-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
trait Trait {}

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

@ -1,11 +1,11 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/argument_order.rs:11:32
--> $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 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:19:23
--> $DIR/argument_order.rs:18:23
|
LL | let _: AlsoBad<7, 'static, u32, 'static, 17, u16>;
| ^^^^^^^

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

@ -1,23 +1,23 @@
error: type parameters must be declared prior to const parameters
--> $DIR/argument_order.rs:5:28
--> $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:11:32
--> $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:11:36
--> $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:19:23
--> $DIR/argument_order.rs:18:23
|
LL | let _: AlsoBad<7, 'static, u32, 'static, 17, u16>;
| ^^^^^^^

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

@ -1,6 +1,5 @@
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
#![cfg_attr(full, feature(const_generics_defaults))]
struct Bad<const N: usize, T> {
//[min]~^ ERROR type parameters must be declared prior to const parameters

18
src/test/ui/const-generics/array-size-in-generic-struct-param.full.stderr
View File

@ -1,18 +0,0 @@
error: constant expression depends on a generic parameter
--> $DIR/array-size-in-generic-struct-param.rs:8:38
|
LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]);
| ^^^^^^^^^^^^
|
= note: this may fail depending on what value the parameter takes
error: constant expression depends on a generic parameter
--> $DIR/array-size-in-generic-struct-param.rs:19:10
|
LL | arr: [u8; CFG.arr_size],
| ^^^^^^^^^^^^^^^^^^
|
= note: this may fail depending on what value the parameter takes
error: aborting due to 2 previous errors

3
src/test/ui/const-generics/array-wrapper-struct-ctor.rs
View File

@ -1,7 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
#![allow(dead_code)]

17
src/test/ui/const-generics/associated-type-bound-fail.min.stderr
View File

@ -1,17 +0,0 @@
error[E0277]: the trait bound `u16: Bar<N>` is not satisfied
--> $DIR/associated-type-bound-fail.rs:13:5
|
LL | type Assoc = u16;
| ^^^^^^^^^^^^^^^^^ the trait `Bar<N>` is not implemented for `u16`
|
= help: the following implementations were found:
<u16 as Bar<3_usize>>
note: required by a bound in `Foo::Assoc`
--> $DIR/associated-type-bound-fail.rs:8:17
|
LL | type Assoc: Bar<N>;
| ^^^^^^ required by this bound in `Foo::Assoc`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

4
src/test/ui/const-generics/associated-type-bound-fail.rs
View File

@ -1,7 +1,3 @@
// revisions: full min
#![cfg_attr(full, allow(incomplete_features))]
#![cfg_attr(full, feature(const_generics))]
trait Bar<const N: usize> {}
trait Foo<const N: usize> {

4
src/test/ui/const-generics/associated-type-bound-fail.full.stderr → src/test/ui/const-generics/associated-type-bound-fail.stderr
View File

@ -1,5 +1,5 @@
error[E0277]: the trait bound `u16: Bar<N>` is not satisfied
--> $DIR/associated-type-bound-fail.rs:13:5
--> $DIR/associated-type-bound-fail.rs:9:5
|
LL | type Assoc = u16;
| ^^^^^^^^^^^^^^^^^ the trait `Bar<N>` is not implemented for `u16`
@ -7,7 +7,7 @@ LL | type Assoc = u16;
= help: the following implementations were found:
<u16 as Bar<3_usize>>
note: required by a bound in `Foo::Assoc`
--> $DIR/associated-type-bound-fail.rs:8:17
--> $DIR/associated-type-bound-fail.rs:4:17
|
LL | type Assoc: Bar<N>;
| ^^^^^^ required by this bound in `Foo::Assoc`

4
src/test/ui/const-generics/associated-type-bound.rs
View File

@ -1,8 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, allow(incomplete_features))]
#![cfg_attr(full, feature(const_generics))]
trait Bar<const N: usize> {}
trait Foo<const N: usize> {

3
src/test/ui/const-generics/auxiliary/const_generic_lib.rs
View File

@ -1,6 +1,3 @@
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
pub struct Struct<const N: usize>(pub [u8; N]);
pub type Alias = Struct<2>;

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

@ -1,6 +1,4 @@
// edition:2018
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
pub trait Foo<const N: usize> {}
struct Local;

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

@ -1,4 +1,4 @@
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// library portion of regression test for #87674

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

@ -1,4 +1,4 @@
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// library portion of testing that `impl Trait<{ expr }>` doesnt

5
src/test/ui/const-generics/broken-mir-1.rs
View File

@ -1,9 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
pub trait Foo {
fn foo(&self);
}

5
src/test/ui/const-generics/broken-mir-2.rs
View File

@ -1,9 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
use std::fmt::Debug;
#[derive(Debug)]

3
src/test/ui/const-generics/cannot-infer-type-for-const-param.rs
View File

@ -1,7 +1,4 @@
// check-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
// This test confirms that the types can be inferred correctly for this example with const
// generics. Previously this would ICE, and more recently error.

52
src/test/ui/const-generics/closing-args-token.min.stderr
View File

@ -1,52 +0,0 @@
error: expressions must be enclosed in braces to be used as const generic arguments
--> $DIR/closing-args-token.rs:10:9
|
LL | S::<5 + 2 >> 7>;
| ^^^^^
|
help: enclose the `const` expression in braces
|
LL | S::<{ 5 + 2 } >> 7>;
| + +
error: comparison operators cannot be chained
--> $DIR/closing-args-token.rs:10:16
|
LL | S::<5 + 2 >> 7>;
| ^ ^
|
help: split the comparison into two
|
LL | S::<5 + 2 >> 7 && 7>;
| ++++
error: comparison operators cannot be chained
--> $DIR/closing-args-token.rs:16:20
|
LL | S::<{ 5 + 2 } >> 7>;
| ^ ^
|
help: split the comparison into two
|
LL | S::<{ 5 + 2 } >> 7 && 7>;
| ++++
error: expected expression, found `;`
--> $DIR/closing-args-token.rs:21:16
|
LL | T::<0 >= 3>;
| ^ expected expression
error: comparison operators cannot be chained
--> $DIR/closing-args-token.rs:27:12
|
LL | T::<x >>= 2 > 0>;
| ^^ ^
|
help: split the comparison into two
|
LL | T::<x >>= 2 && 2 > 0>;
| ++++
error: aborting due to 5 previous errors

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

@ -1,9 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
fn foo<const N: usize>(v: &[u8; N]) -> &[u8] {
v
}

4
src/test/ui/const-generics/concrete-const-as-fn-arg.rs
View File

@ -1,9 +1,5 @@
// Test that a concrete const type i.e. A<2>, can be used as an argument type in a function
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
struct A<const N: usize>; // ok

4
src/test/ui/const-generics/concrete-const-impl-method.rs
View File

@ -1,10 +1,6 @@
// Test that a method/associated non-method within an impl block of a concrete const type i.e. A<2>,
// is callable.
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
pub struct A<const N: u32>;

2
src/test/ui/const-generics/condition-in-trait-const-arg.rs
View File

@ -2,7 +2,7 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, feature(generic_const_exprs))]
#![cfg_attr(full, allow(incomplete_features))]
trait IsZeroTrait<const IS_ZERO: bool>{}

2
src/test/ui/const-generics/conservative_is_privately_uninhabited_uses_correct_param_env-1.rs
View File

@ -1,5 +1,5 @@
// run-pass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// This tests that the `conservative_is_privately_uninhabited` fn doesn't cause

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

@ -1,5 +1,5 @@
// run-pass
#![feature(const_generics, generic_const_exprs)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// This tests that the `conservative_is_privately_uninhabited` fn doesn't cause

78
src/test/ui/const-generics/const-arg-in-const-arg.min.stderr
View File

@ -5,7 +5,7 @@ LL | let _: [u8; foo::<T>()];
| ^ cannot perform const operation using `T`
|
= note: type parameters may not be used in const expressions
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:14:23
@ -14,7 +14,7 @@ LL | let _: [u8; bar::<N>()];
| ^ cannot perform const operation using `N`
|
= help: const parameters may only be used as standalone arguments, i.e. `N`
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:24:23
@ -23,7 +23,7 @@ LL | let _ = [0; bar::<N>()];
| ^ cannot perform const operation using `N`
|
= help: const parameters may only be used as standalone arguments, i.e. `N`
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:29:24
@ -32,7 +32,7 @@ LL | let _: Foo<{ foo::<T>() }>;
| ^ cannot perform const operation using `T`
|
= note: type parameters may not be used in const expressions
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:30:24
@ -41,7 +41,7 @@ LL | let _: Foo<{ bar::<N>() }>;
| ^ cannot perform const operation using `N`
|
= help: const parameters may only be used as standalone arguments, i.e. `N`
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:35:27
@ -50,7 +50,7 @@ LL | let _ = Foo::<{ foo::<T>() }>;
| ^ cannot perform const operation using `T`
|
= note: type parameters may not be used in const expressions
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error: generic parameters may not be used in const operations
--> $DIR/const-arg-in-const-arg.rs:36:27
@ -59,7 +59,7 @@ LL | let _ = Foo::<{ bar::<N>() }>;
| ^ cannot perform const operation using `N`
|
= help: const parameters may only be used as standalone arguments, i.e. `N`
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:15:23
@ -67,8 +67,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: [u8; faz::<'a>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:16:23
@ -76,8 +76,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: [u8; baz::<'a>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:17:23
@ -85,8 +85,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: [u8; faz::<'b>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:18:23
@ -94,8 +94,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: [u8; baz::<'b>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:25:23
@ -103,8 +103,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = [0; faz::<'a>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:26:23
@ -112,8 +112,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = [0; baz::<'a>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:27:23
@ -121,8 +121,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = [0; faz::<'b>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:28:23
@ -130,8 +130,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = [0; baz::<'b>(&())];
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:31:24
@ -139,8 +139,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: Foo<{ faz::<'a>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:32:24
@ -148,8 +148,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: Foo<{ baz::<'a>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:33:24
@ -157,8 +157,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: Foo<{ faz::<'b>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:34:24
@ -166,8 +166,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _: Foo<{ baz::<'b>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:37:27
@ -175,8 +175,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = Foo::<{ faz::<'a>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:38:27
@ -184,8 +184,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = Foo::<{ baz::<'a>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:39:27
@ -193,8 +193,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = Foo::<{ faz::<'b>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error[E0658]: a non-static lifetime is not allowed in a `const`
--> $DIR/const-arg-in-const-arg.rs:40:27
@ -202,8 +202,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
LL | let _ = Foo::<{ baz::<'b>(&()) }>;
| ^^
|
= note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
= help: add `#![feature(const_generics)]` to the crate attributes to enable
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
error: aborting due to 23 previous errors

2
src/test/ui/const-generics/const-arg-in-const-arg.rs
View File

@ -1,5 +1,5 @@
// revisions: min
// FIXME(const_generics): This test currently causes an ICE because
// FIXME(generic_const_exprs): This test currently causes an ICE because
// we don't yet correctly deal with lifetimes, reenable this test once
// this is fixed.

5
src/test/ui/const-generics/const-arg-in-fn.rs
View File

@ -1,9 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
fn const_u32_identity<const X: u32>() -> u32 {
X
}

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

@ -1,9 +0,0 @@
error[E0747]: constant provided when a type was expected
--> $DIR/const-arg-type-arg-misordered.rs:7:35
|
LL | fn foo<const N: usize>() -> Array<N, ()> {
| ^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0747`.

4
src/test/ui/const-generics/const-arg-type-arg-misordered.rs
View File

@ -1,7 +1,3 @@
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
type Array<T, const N: usize> = [T; N];
fn foo<const N: usize>() -> Array<N, ()> {

2
src/test/ui/const-generics/const-arg-type-arg-misordered.min.stderr → src/test/ui/const-generics/const-arg-type-arg-misordered.stderr
View File

@ -1,5 +1,5 @@
error[E0747]: constant provided when a type was expected
--> $DIR/const-arg-type-arg-misordered.rs:7:35
--> $DIR/const-arg-type-arg-misordered.rs:3:35
|
LL | fn foo<const N: usize>() -> Array<N, ()> {
| ^

15
src/test/ui/const-generics/const-argument-cross-crate-mismatch.min.stderr
View File

@ -1,15 +0,0 @@
error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:9:67
|
LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
| ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:11:65
|
LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
| ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

3
src/test/ui/const-generics/const-argument-cross-crate-mismatch.rs
View File

@ -1,7 +1,4 @@
// aux-build:const_generic_lib.rs
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
extern crate const_generic_lib;

4
src/test/ui/const-generics/const-argument-cross-crate-mismatch.full.stderr → src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr
View File

@ -1,11 +1,11 @@
error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:9:67
--> $DIR/const-argument-cross-crate-mismatch.rs:6:67
|
LL | let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
| ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
error[E0308]: mismatched types
--> $DIR/const-argument-cross-crate-mismatch.rs:11:65
--> $DIR/const-argument-cross-crate-mismatch.rs:8:65
|
LL | let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
| ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements

29
src/test/ui/const-generics/const-argument-if-length.full.stderr
View File

@ -1,24 +1,5 @@
error[E0277]: the size for values of type `T` cannot be known at compilation time
--> $DIR/const-argument-if-length.rs:7:28
|
LL | pub const fn is_zst<T: ?Sized>() -> usize {
| - this type parameter needs to be `std::marker::Sized`
LL | if std::mem::size_of::<T>() == 0 {
| ^ doesn't have a size known at compile-time
|
note: required by a bound in `std::mem::size_of`
--> $SRC_DIR/core/src/mem/mod.rs:LL:COL
|
LL | pub const fn size_of<T>() -> usize {
| ^ required by this bound in `std::mem::size_of`
help: consider removing the `?Sized` bound to make the type parameter `Sized`
|
LL - pub const fn is_zst<T: ?Sized>() -> usize {
LL + pub const fn is_zst<T>() -> usize {
|
error[E0277]: the size for values of type `T` cannot be known at compilation time
--> $DIR/const-argument-if-length.rs:16:12
--> $DIR/const-argument-if-length.rs:15:12
|
LL | pub struct AtLeastByte<T: ?Sized> {
| - this type parameter needs to be `std::marker::Sized`
@ -41,6 +22,14 @@ help: the `Box` type always has a statically known size and allocates its conten
LL | value: Box<T>,
| ++++ +
error: unconstrained generic constant
--> $DIR/const-argument-if-length.rs:17:10
|
LL | pad: [u8; is_zst::<T>()],
| ^^^^^^^^^^^^^^^^^^^
|
= help: try adding a `where` bound using this expression: `where [(); is_zst::<T>()]:`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

6
src/test/ui/const-generics/const-argument-if-length.min.stderr
View File

@ -1,14 +1,14 @@
error: generic parameters may not be used in const operations
--> $DIR/const-argument-if-length.rs:18:24
--> $DIR/const-argument-if-length.rs:17:24
|
LL | pad: [u8; is_zst::<T>()],
| ^ cannot perform const operation using `T`
|
= note: type parameters may not be used in const expressions
= help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
= help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
error[E0277]: the size for values of type `T` cannot be known at compilation time
--> $DIR/const-argument-if-length.rs:16:12
--> $DIR/const-argument-if-length.rs:15:12
|
LL | pub struct AtLeastByte<T: ?Sized> {
| - this type parameter needs to be `std::marker::Sized`

4
src/test/ui/const-generics/const-argument-if-length.rs
View File

@ -1,11 +1,10 @@
// revisions: full min
#![cfg_attr(full, feature(generic_const_exprs))]
#![cfg_attr(full, allow(incomplete_features))]
#![cfg_attr(full, feature(const_generics))]
pub const fn is_zst<T: ?Sized>() -> usize {
if std::mem::size_of::<T>() == 0 {
//[full]~^ ERROR the size for values of type `T` cannot be known at compilation time
1
} else {
0
@ -17,6 +16,7 @@ pub struct AtLeastByte<T: ?Sized> {
//~^ ERROR the size for values of type `T` cannot be known at compilation time
pad: [u8; is_zst::<T>()],
//[min]~^ ERROR generic parameters may not be used in const operations
//[full]~^^ ERROR unconstrained generic constant
}
fn main() {}

2
src/test/ui/const-generics/const-argument-non-static-lifetime.rs
View File

@ -2,7 +2,7 @@
// revisions: full
// FIXME(#75323) Omitted min revision for now due to ICE.
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, feature(generic_const_exprs))]
#![cfg_attr(full, allow(incomplete_features))]
#![allow(dead_code)]

13
src/test/ui/const-generics/const-expression-parameter.min.stderr
View File

@ -1,13 +0,0 @@
error: expressions must be enclosed in braces to be used as const generic arguments
--> $DIR/const-expression-parameter.rs:15:20
|
LL | i32_identity::<1 + 2>();
| ^^^^^
|
help: enclose the `const` expression in braces
|
LL | i32_identity::<{ 1 + 2 }>();
| + +
error: aborting due to previous error

4
src/test/ui/const-generics/const-fn-with-const-param.rs
View File

@ -1,9 +1,5 @@
// Checks that `const fn` with const params can be used.
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
const fn const_u32_identity<const X: u32>() -> u32 {
X

19
src/test/ui/const-generics/const-generic-array-wrapper.rs
View File

@ -1,19 +0,0 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
struct Foo<T, const N: usize>([T; N]);
impl<T, const N: usize> Foo<T, N> {
fn foo(&self) -> usize {
N
}
}
fn main() {
let foo = Foo([0u32; 21]);
assert_eq!(foo.0, [0u32; 21]);
assert_eq!(foo.foo(), 21);
}

4
src/test/ui/const-generics/const-generic-type_name.rs
View File

@ -1,8 +1,4 @@
// run-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
#[derive(Debug)]
struct S<const N: usize>;

4
src/test/ui/const-generics/const-param-after-const-literal-arg.rs
View File

@ -1,8 +1,4 @@
// check-pass
// revisions: full min
#![cfg_attr(full, feature(const_generics))]
#![cfg_attr(full, allow(incomplete_features))]
struct Foo<const A: usize, const B: usize>;

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

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

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

@ -1,32 +1,14 @@
error: lifetime parameters must be declared prior to const parameters
--> $DIR/const-param-before-other-params.rs:5:21
|
LL | fn bar<const X: (), 'a>(_: &'a ()) {
| --------------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, const X: ()>`
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:10:21
--> $DIR/const-param-before-other-params.rs:9:21
|
LL | fn foo<const X: (), T>(_: &T) {}
| --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: ()>`
LL | fn foo<const X: u8, T>(_: &T) {}
| --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: u8>`
error: `()` is forbidden as the type of a const generic parameter
--> $DIR/const-param-before-other-params.rs:5:17
|
LL | fn bar<const X: (), 'a>(_: &'a ()) {
| ^^
|
= note: the only supported types are integers, `bool` and `char`
= help: more complex types are supported with `#![feature(const_generics)]`
error: `()` is forbidden as the type of a const generic parameter
--> $DIR/const-param-before-other-params.rs:10:17
|
LL | fn foo<const X: (), T>(_: &T) {}
| ^^
|
= note: the only supported types are integers, `bool` and `char`
= help: more complex types are supported with `#![feature(const_generics)]`
error: aborting due to 4 previous errors
error: aborting due to 2 previous errors

Some files were not shown because too many files have changed in this diff Show More