mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #88369 - lcnr:cec-rename, r=oli-obk

Browse source 
update const generics feature gates

**tl;dr: split const generics into three features: `adt_const_params`, `const_generics_defaults` and `generic_const_exprs`**

continuing the work of `@BoxyUwU` in #88324, this PR
- renames `feature(const_evaluatable_checked)` to `feature(generic_const_exprs)` which now doesn't need any other feature gate to work. Previously `feature(const_evaluatable_checked)` was only useful in combination with `feature(const_generics)`.
- completely removes `feature(lazy_normalization_consts)`. This feature only supplied the parents generics to anonymous constants, which is pretty useless as generic anon consts are only allowed with `feature(generic_const_exprs)` anyways.
- moves the ability to use additional const param types from `feature(const_generics)` into `feature(adt_const_params)`. As `feature(const_generics)` is now mostly useless without `feature(generic_const_exprs)` we also remove that feature flag.
- updates tests, removing duplicates and unnecessary revisions in some cases and also deletes all unused `*.stderr` files.

I not also remove the ordering restriction for const and type parameters if any of the three const generics features is active.
This ordering restriction feels like the only "real" use of the current `feature(const_generics)` right now so this change isn't a perfect solution, but as I intend to stabilize the ordering - and `feature(const_generics_defaults)` -  in the very near future, I think this is acceptable for now.

---

cc `@rust-lang/project-const-generics` about the new feature names and this change in general.

I don't think we need any external approval for this change but I do intend to publish an update to the const generics tracking issue the day this PR lands, so I don't want this merged yet.

Apologies to whoever ends up reviewing this PR 😅 ❤️

r? rust-lang/project-const-generics
This commit is contained in:
bors 2021-08-30 22:21:01 +00:00
commit 6f388bb369
613 changed files with 917 additions and 4514 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_ast/src/ast.rs
View file

@ -332,8 +332,8 @@ pub type GenericBounds = Vec<GenericBound>;
pub enum ParamKindOrd {
Lifetime,
Type,
// `unordered` is only `true` if `sess.has_features().const_generics`
// is active. Specifically, if it's only `min_const_generics`, it will still require
// `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 },
// `Infer` is not actually constructed directly from the AST, but is implicitly constructed

2
compiler/rustc_ast_passes/src/ast_validation.rs
View file

@ -1351,7 +1351,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
}
fn visit_generics(&mut self, generics: &'a Generics) {
let cg_defaults = self.session.features_untracked().const_generics_defaults;
let cg_defaults = self.session.features_untracked().unordered_const_ty_params();
let mut prev_param_default = None;
for param in &generics.params {

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(adt_const_params)]
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(adt_const_params)]
#[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(adt_const_params)]
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(adt_const_params)]
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),

17
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 || self.generic_const_exprs || self.adt_const_params
}
/// 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),
@ -545,15 +542,9 @@ declare_features! (
/// Allows capturing variables in scope using format_args!
(active, format_args_capture, "1.46.0", Some(67984), None),
/// Lazily evaluate constants. This allows constants to depend on type parameters.
(incomplete, lazy_normalization_consts, "1.46.0", Some(72219), None),
/// Allows `if let` guard in match arms.
(active, if_let_guard, "1.47.0", Some(51114), None),
/// Allows non-trivial generic constants which have to be manually propagated upwards.
(incomplete, const_evaluatable_checked, "1.48.0", Some(76560), None),
/// Allows basic arithmetic on floating point types in a `const fn`.
(active, const_fn_floating_point_arithmetic, "1.48.0", Some(57241), None),
@ -679,6 +670,12 @@ declare_features! (
/// Allows using doc(primitive) without a future-incompat warning
(active, doc_primitive, "1.56.0", Some(88070), None),
/// 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, adt_const_params, "1.56.0", Some(44580), None),
// -------------------------------------------------------------------------
// feature-group-end: actual feature gates
// -------------------------------------------------------------------------

7
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(adt_const_params]` 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")),
@ -128,9 +131,13 @@ declare_features! (
Some("Removed in favor of `~const` bound in #![feature(const_trait_impl)]")),
/// Allows `#[no_debug]`.
(removed, no_debug, "1.43.0", Some(29721), None, Some("removed due to lack of demand")),
/// Lazily evaluate constants. This allows constants to depend on type parameters.
(removed, lazy_normalization_consts, "1.46.0", Some(72219), None, Some("superseded by `generic_const_exprs`")),
/// Allows comparing raw pointers during const eval.
(removed, const_compare_raw_pointers, "1.46.0", Some(53020), None,
Some("cannot be allowed in const eval in any meaningful way")),
/// Allows non-trivial generic constants which have to be manually propagated upwards.
(removed, const_evaluatable_checked, "1.48.0", Some(76560), None, Some("renamed to `generic_const_exprs`")),
/// Allows using the `#[link_args]` attribute.
(removed, link_args, "1.53.0", Some(29596), None,
Some("removed in favor of using `-C link-arg=ARG` on command line, \

2
compiler/rustc_hir/src/def.rs
View file

@ -307,7 +307,7 @@ pub enum Res<Id = hir::HirId> {
/// We do however allow `Self` in repeat expression even if it is generic to not break code
/// which already works on stable while causing the `const_evaluatable_unchecked` future compat lint.
///
/// FIXME(lazy_normalization_consts): Remove this bodge once that feature is stable.
/// FIXME(generic_const_exprs): Remove this bodge once that feature is stable.
SelfTy(
/// Optionally, the trait associated with this `Self` type.
Option<DefId>,

2
compiler/rustc_infer/src/infer/canonical/query_response.rs
View file

@ -678,7 +678,7 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for QueryTypeRelatingDelegate<'_, 'tcx> {
fn const_equate(&mut self, _a: &'tcx Const<'tcx>, _b: &'tcx Const<'tcx>) {
span_bug!(
self.cause.span(self.infcx.tcx),
"lazy_normalization_consts: unreachable `const_equate`"
"generic_const_exprs: unreachable `const_equate`"
);
}

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.lazy_normalization_consts
// Note: We only use lazy normalization for generic const expressions.
features.generic_const_exprs
}
#[inline]

4
compiler/rustc_middle/src/ty/relate.rs
View file

@ -577,13 +577,13 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
}
(ty::ConstKind::Unevaluated(au), ty::ConstKind::Unevaluated(bu))
if tcx.features().const_evaluatable_checked =>
if tcx.features().generic_const_exprs =>
{
tcx.try_unify_abstract_consts((au.shrink(), bu.shrink()))
}
// While this is slightly incorrect, it shouldn't matter for `min_const_generics`
// and is the better alternative to waiting until `const_evaluatable_checked` can
// and is the better alternative to waiting until `generic_const_exprs` can
// be stabilized.
(ty::ConstKind::Unevaluated(au), ty::ConstKind::Unevaluated(bu))
if au.def == bu.def && au.promoted == bu.promoted =>

4
compiler/rustc_privacy/src/lib.rs
View file

@ -136,7 +136,7 @@ where
}
ty::PredicateKind::RegionOutlives(..) => ControlFlow::CONTINUE,
ty::PredicateKind::ConstEvaluatable(uv)
if self.def_id_visitor.tcx().features().const_evaluatable_checked =>
if self.def_id_visitor.tcx().features().generic_const_exprs =>
{
let tcx = self.def_id_visitor.tcx();
if let Ok(Some(ct)) = AbstractConst::new(tcx, uv) {
@ -1809,7 +1809,7 @@ impl SearchInterfaceForPrivateItemsVisitor<'tcx> {
self.visit(self.tcx.type_of(param.def_id));
}
}
// FIXME(const_evaluatable_checked): May want to look inside const here
// FIXME(generic_const_exprs): May want to look inside const here
GenericParamDefKind::Const { .. } => {
self.visit(self.tcx.type_of(param.def_id));
}

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(const_evaluatable_checked)]` \
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);

10
compiler/rustc_resolve/src/lib.rs
View file

@ -2734,10 +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.lazy_normalization_consts)
{
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.
@ -2809,10 +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.lazy_normalization_consts)
{
if !(trivial || features.generic_const_exprs) {
if record_used {
self.report_error(
span,

2
compiler/rustc_span/src/symbol.rs
View file

@ -284,6 +284,7 @@ symbols! {
add_assign,
add_with_overflow,
address,
adt_const_params,
advanced_slice_patterns,
adx_target_feature,
alias,
@ -662,6 +663,7 @@ symbols! {
generators,
generic_arg_infer,
generic_associated_types,
generic_const_exprs,
generic_param_attrs,
get_context,
global_allocator,

12
compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
View file

@ -34,7 +34,7 @@ pub fn is_const_evaluatable<'cx, 'tcx>(
span: Span,
) -> Result<(), NotConstEvaluatable> {
debug!("is_const_evaluatable({:?})", uv);
if infcx.tcx.features().const_evaluatable_checked {
if infcx.tcx.features().generic_const_exprs {
let tcx = infcx.tcx;
match AbstractConst::new(tcx, uv)? {
// We are looking at a generic abstract constant.
@ -537,9 +537,9 @@ pub(super) fn mir_abstract_const<'tcx>(
tcx: TyCtxt<'tcx>,
def: ty::WithOptConstParam<LocalDefId>,
) -> Result<Option<&'tcx [mir::abstract_const::Node<'tcx>]>, ErrorReported> {
if tcx.features().const_evaluatable_checked {
if tcx.features().generic_const_exprs {
match tcx.def_kind(def.did) {
// FIXME(const_evaluatable_checked): We currently only do this for anonymous constants,
// FIXME(generic_const_exprs): We currently only do this for anonymous constants,
// meaning that we do not look into associated constants. I(@lcnr) am not yet sure whether
// we want to look into them or treat them as opaque projections.
//
@ -568,7 +568,7 @@ pub(super) fn try_unify_abstract_consts<'tcx>(
Ok(false)
})()
.unwrap_or_else(|ErrorReported| true)
// FIXME(const_evaluatable_checked): We should instead have this
// FIXME(generic_const_exprs): We should instead have this
// method return the resulting `ty::Const` and return `ConstKind::Error`
// on `ErrorReported`.
}
@ -656,13 +656,13 @@ pub(super) fn try_unify<'tcx>(
// branch should only be taking when dealing with associated constants, at
// which point directly comparing them seems like the desired behavior.
//
// FIXME(const_evaluatable_checked): This isn't actually the case.
// FIXME(generic_const_exprs): This isn't actually the case.
// We also take this branch for concrete anonymous constants and
// expand generic anonymous constants with concrete substs.
(ty::ConstKind::Unevaluated(a_uv), ty::ConstKind::Unevaluated(b_uv)) => {
a_uv == b_uv
}
// FIXME(const_evaluatable_checked): We may want to either actually try
// FIXME(generic_const_exprs): We may want to either actually try
// to evaluate `a_ct` and `b_ct` if they are are fully concrete or something like
// this, for now we just return false here.
_ => false,

4
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -794,7 +794,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
)
}
SelectionError::NotConstEvaluatable(NotConstEvaluatable::MentionsParam) => {
if !self.tcx.features().const_evaluatable_checked {
if !self.tcx.features().generic_const_exprs {
let mut err = self.tcx.sess.struct_span_err(
span,
"constant expression depends on a generic parameter",
@ -803,7 +803,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
// issue. However, this is currently not actually possible
// (see https://github.com/rust-lang/rust/issues/66962#issuecomment-575907083).
//
// Note that with `feature(const_evaluatable_checked)` this case should not
// Note that with `feature(generic_const_exprs)` this case should not
// be reachable.
err.note("this may fail depending on what value the parameter takes");
err.emit();

2
compiler/rustc_trait_selection/src/traits/fulfill.rs
View file

@ -572,7 +572,7 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
ty::PredicateKind::ConstEquate(c1, c2) => {
debug!(?c1, ?c2, "equating consts");
let tcx = self.selcx.tcx();
if tcx.features().const_evaluatable_checked {
if tcx.features().generic_const_exprs {
// FIXME: we probably should only try to unify abstract constants
// if the constants depend on generic parameters.
//

2
compiler/rustc_trait_selection/src/traits/object_safety.rs
View file

@ -855,7 +855,7 @@ fn contains_illegal_self_type_reference<'tcx, T: TypeFoldable<'tcx>>(
fn visit_predicate(&mut self, pred: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
if let ty::PredicateKind::ConstEvaluatable(ct) = pred.kind().skip_binder() {
// FIXME(const_evaluatable_checked): We should probably deduplicate the logic for
// FIXME(generic_const_exprs): We should probably deduplicate the logic for
// `AbstractConst`s here, it might make sense to change `ConstEvaluatable` to
// take a `ty::Const` instead.
use rustc_middle::mir::abstract_const::Node;

2
compiler/rustc_trait_selection/src/traits/select/mod.rs
View file

@ -619,7 +619,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
ty::PredicateKind::ConstEquate(c1, c2) => {
debug!(?c1, ?c2, "evaluate_predicate_recursively: equating consts");
if self.tcx().features().const_evaluatable_checked {
if self.tcx().features().generic_const_exprs {
// FIXME: we probably should only try to unify abstract constants
// if the constants depend on generic parameters.
//

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().adt_const_params {
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(adt_const_params)]`",
);
}
err.emit()

4
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
@ -2300,7 +2300,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericP
}
}
if tcx.features().const_evaluatable_checked {
if tcx.features().generic_const_exprs {
predicates.extend(const_evaluatable_predicates_of(tcx, def_id.expect_local()));
}

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(adt_const_params, 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, const_evaluatable_checked)]
#![feature(generic_const_exprs, adt_const_params)]
#![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, const_evaluatable_checked)]
#![feature(generic_const_exprs, adt_const_params, 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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![feature(generic_const_exprs, adt_const_params)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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(adt_const_params)]
#![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(const_evaluatable_checked, 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(lazy_normalization_consts)]
#![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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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(adt_const_params))]
#![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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![feature(generic_const_exprs)]
#![allow(incomplete_features)]
// library portion of testing that `impl Trait<{ expr }>` doesnt

0
src/test/ui/lazy_normalization_consts/trait-resolution-breakage.rs → src/test/ui/const-generics/backcompat/trait-resolution-breakage.rs
View file

0
src/test/ui/lazy_normalization_consts/unevaluated-consts.rs → src/test/ui/const-generics/backcompat/unevaluated-consts.rs
View file

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, const_evaluatable_checked)]
#![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, const_evaluatable_checked)]
#![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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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(const_evaluatable_checked)]` 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;

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