}
}
-enum GenericPosition {
- Param,
- Arg,
-}
-
-fn validate_generics_order<'a>(
+fn validate_generic_param_order<'a>(
sess: &Session,
handler: &rustc_errors::Handler,
generics: impl Iterator<Item = (ParamKindOrd, Option<&'a [GenericBound]>, Span, Option<String>)>,
- pos: GenericPosition,
span: Span,
) {
let mut max_param: Option<ParamKindOrd> = None;
let mut out_of_order = FxHashMap::default();
let mut param_idents = vec![];
- let mut found_type = false;
- let mut found_const = false;
for (kind, bounds, span, ident) in generics {
if let Some(ident) = ident {
}
Some(_) | None => *max_param = Some(kind),
};
- match kind {
- ParamKindOrd::Type => found_type = true,
- ParamKindOrd::Const => found_const = true,
- _ => {}
- }
}
let mut ordered_params = "<".to_string();
}
ordered_params += ">";
- let pos_str = match pos {
- GenericPosition::Param => "parameter",
- GenericPosition::Arg => "argument",
- };
-
for (param_ord, (max_param, spans)) in &out_of_order {
- let mut err = handler.struct_span_err(
- spans.clone(),
- &format!(
- "{} {pos}s must be declared prior to {} {pos}s",
- param_ord,
- max_param,
- pos = pos_str,
- ),
- );
- if let GenericPosition::Param = pos {
- err.span_suggestion(
- span,
+ let mut err =
+ handler.struct_span_err(
+ spans.clone(),
&format!(
- "reorder the {}s: lifetimes, then types{}",
- pos_str,
- if sess.features_untracked().const_generics { ", then consts" } else { "" },
+ "{} parameters must be declared prior to {} parameters",
+ param_ord, max_param,
),
- ordered_params.clone(),
- Applicability::MachineApplicable,
);
- }
+ err.span_suggestion(
+ span,
+ &format!(
+ "reorder the parameters: lifetimes, then types{}",
+ if sess.features_untracked().const_generics { ", then consts" } else { "" },
+ ),
+ ordered_params.clone(),
+ Applicability::MachineApplicable,
+ );
err.emit();
}
-
- // FIXME(const_generics): we shouldn't have to abort here at all, but we currently get ICEs
- // if we don't. Const parameters and type parameters can currently conflict if they
- // are out-of-order.
- if !out_of_order.is_empty() && found_type && found_const {
- FatalError.raise();
- }
}
impl<'a> Visitor<'a> for AstValidator<'a> {
match *generic_args {
GenericArgs::AngleBracketed(ref data) => {
walk_list!(self, visit_generic_arg, &data.args);
- validate_generics_order(
- self.session,
- self.err_handler(),
- data.args.iter().map(|arg| {
- (
- match arg {
- GenericArg::Lifetime(..) => ParamKindOrd::Lifetime,
- GenericArg::Type(..) => ParamKindOrd::Type,
- GenericArg::Const(..) => ParamKindOrd::Const,
- },
- None,
- arg.span(),
- None,
- )
- }),
- GenericPosition::Arg,
- generic_args.span(),
- );
// Type bindings such as `Item = impl Debug` in `Iterator<Item = Debug>`
// are allowed to contain nested `impl Trait`.
}
}
- validate_generics_order(
+ validate_generic_param_order(
self.session,
self.err_handler(),
generics.params.iter().map(|param| {
};
(kind, Some(&*param.bounds), param.ident.span, ident)
}),
- GenericPosition::Param,
generics.span,
);
E0744: include_str!("./error_codes/E0744.md"),
E0745: include_str!("./error_codes/E0745.md"),
E0746: include_str!("./error_codes/E0746.md"),
+E0747: include_str!("./error_codes/E0747.md"),
;
// E0006, // merged with E0005
// E0008, // cannot bind by-move into a pattern guard
--- /dev/null
+Generic arguments must be provided in the same order as the corresponding generic
+parameters are declared.
+
+Erroneous code example:
+
+```compile_fail,E0747
+struct S<'a, T>(&'a T);
+
+type X = S<(), 'static>; // error: the type argument is provided before the lifetime argument
+```
parent_substs: &[subst::GenericArg<'tcx>],
has_self: bool,
self_ty: Option<Ty<'tcx>>,
+ arg_count_mismatch: bool,
args_for_def_id: impl Fn(DefId) -> (Option<&'b GenericArgs<'b>>, bool),
provided_kind: impl Fn(&GenericParamDef, &GenericArg<'_>) -> subst::GenericArg<'tcx>,
mut inferred_kind: impl FnMut(
// methods in `subst.rs`, so that we can iterate over the arguments and
// parameters in lock-step linearly, instead of trying to match each pair.
let mut substs: SmallVec<[subst::GenericArg<'tcx>; 8]> = SmallVec::with_capacity(count);
-
// Iterate over each segment of the path.
while let Some((def_id, defs)) = stack.pop() {
let mut params = defs.params.iter().peekable();
let mut args =
generic_args.iter().flat_map(|generic_args| generic_args.args.iter()).peekable();
+ let arg_kind = |arg| match arg {
+ &GenericArg::Lifetime(_) => "lifetime",
+ &GenericArg::Type(_) => "type",
+ &GenericArg::Const(_) => "constant",
+ };
+
+ // If we encounter a type or const when we expect a lifetime, we infer the lifetimes.
+ // If we later encounter a lifetime, we know that the arguments were provided in the
+ // wrong order. `force_infer_lt` records the type or const that forced lifetimes to be
+ // inferred, so we can use it for diagnostics later.
+ let mut force_infer_lt = None;
+
loop {
// We're going to iterate through the generic arguments that the user
// provided, matching them with the generic parameters we expect.
// We expected a lifetime argument, but got a type or const
// argument. That means we're inferring the lifetimes.
substs.push(inferred_kind(None, param, infer_args));
+ force_infer_lt = Some(arg);
params.next();
}
- (_, _) => {
+ (_, kind) => {
// We expected one kind of parameter, but the user provided
- // another. This is an error, but we need to handle it
- // gracefully so we can report sensible errors.
- // In this case, we're simply going to infer this argument.
- args.next();
+ // another. This is an error. However, if we already know that
+ // the arguments don't match up with the parameters, we won't issue
+ // an additional error, as the user already knows what's wrong.
+ if !arg_count_mismatch {
+ let param_kind = match kind {
+ GenericParamDefKind::Lifetime => "lifetime",
+ GenericParamDefKind::Type { .. } => "type",
+ GenericParamDefKind::Const => "constant",
+ };
+ struct_span_err!(
+ tcx.sess,
+ arg.span(),
+ E0747,
+ "{} provided when a {} was expected",
+ arg_kind(arg),
+ param_kind,
+ )
+ .emit();
+ }
+
+ // We've reported the error, but we want to make sure that this
+ // problem doesn't bubble down and create additional, irrelevant
+ // errors. In this case, we're simply going to ignore the argument
+ // and any following arguments. The rest of the parameters will be
+ // inferred.
+ while args.next().is_some() {}
}
}
}
- (Some(_), None) => {
+ (Some(&arg), None) => {
// We should never be able to reach this point with well-formed input.
- // Getting to this point means the user supplied more arguments than
- // there are parameters.
- args.next();
+ // There are two situations in which we can encounter this issue.
+ //
+ // 1. The number of arguments is incorrect. In this case, an error
+ // will already have been emitted, and we can ignore it. This case
+ // also occurs when late-bound lifetime parameters are present, yet
+ // the lifetime arguments have also been explicitly specified by the
+ // user.
+ // 2. We've inferred some lifetimes, which have been provided later (i.e.
+ // after a type or const). We want to throw an error in this case.
+
+ if !arg_count_mismatch {
+ let kind = arg_kind(arg);
+ assert_eq!(kind, "lifetime");
+ let provided =
+ force_infer_lt.expect("lifetimes ought to have been inferred");
+ struct_span_err!(
+ tcx.sess,
+ provided.span(),
+ E0747,
+ "{} provided when a {} was expected",
+ arg_kind(provided),
+ kind,
+ )
+ .emit();
+ }
+
+ break;
}
(None, Some(¶m)) => {
// If there are fewer arguments than parameters, it means
// we're inferring the remaining arguments.
substs.push(inferred_kind(Some(&substs), param, infer_args));
- args.next();
params.next();
}
(None, None) => break,
assert!(self_ty.is_none() && parent_substs.is_empty());
}
- let (_, potential_assoc_types) = Self::check_generic_arg_count(
+ let (arg_count_mismatch, potential_assoc_types) = Self::check_generic_arg_count(
tcx,
span,
&generic_params,
parent_substs,
self_ty.is_some(),
self_ty,
+ arg_count_mismatch,
// Provide the generic args, and whether types should be inferred.
|did| {
if did == def_id {
// If they were not explicitly supplied, just construct fresh
// variables.
let generics = self.tcx.generics_of(pick.item.def_id);
- AstConv::check_generic_arg_count_for_call(
+ let arg_count_mismatch = AstConv::check_generic_arg_count_for_call(
self.tcx, self.span, &generics, &seg, true, // `is_method_call`
);
parent_substs,
false,
None,
+ arg_count_mismatch,
// Provide the generic args, and whether types should be inferred.
|def_id| {
// The last component of the returned tuple here is unimportant.
&[][..],
has_self,
self_ty,
+ !infer_args_for_err.is_empty(),
// Provide the generic args, and whether types should be inferred.
|def_id| {
if let Some(&PathSeg(_, index)) =
let object_lifetime_defaults = tcx.object_lifetime_defaults(hir_id);
- // Now create the real type parameters.
+ // Now create the real type and const parameters.
let type_start = own_start - has_self as u32 + params.len() as u32;
let mut i = 0;
params.extend(ast_generics.params.iter().filter_map(|param| {
--- /dev/null
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+
+type Array<T, const N: usize> = [T; N];
+
+fn foo<const N: usize>() -> Array<N, ()> { //~ ERROR constant provided when a type was expected
+ unimplemented!()
+}
+
+fn main() {}
--- /dev/null
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+ --> $DIR/const-arg-type-arg-misordered.rs:1:12
+ |
+LL | #![feature(const_generics)]
+ | ^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+
+error[E0747]: constant provided when a type was expected
+ --> $DIR/const-arg-type-arg-misordered.rs:6: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`.
--- /dev/null
+// check-pass
+
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+
+struct Foo<const A: usize, const B: usize>;
+
+impl<const A: usize> Foo<1, A> {} // ok
+
+fn main() {}
--- /dev/null
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+ --> $DIR/const-param-after-const-literal-arg.rs:3:12
+ |
+LL | #![feature(const_generics)]
+ | ^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+
#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
fn bar<const X: (), 'a>(_: &'a ()) {
//~^ ERROR lifetime parameters must be declared prior to const parameters
error: lifetime parameters must be declared prior to const parameters
- --> $DIR/const-param-before-other-params.rs:3:21
+ --> $DIR/const-param-before-other-params.rs:4:21
|
LL | fn bar<const X: (), 'a>(_: &'a ()) {
| --------------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, const X: ()>`
error: type parameters must be declared prior to const parameters
- --> $DIR/const-param-before-other-params.rs:7:21
+ --> $DIR/const-param-before-other-params.rs:8:21
|
LL | fn foo<const X: (), T>(_: &T) {
| --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: ()>`
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+ --> $DIR/const-param-before-other-params.rs:1:12
+ |
+LL | #![feature(const_generics)]
+ | ^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(incomplete_features)]` on by default
+
error: aborting due to 2 previous errors
let _x = (*start..*end)
.map(|x| S { a: start, b: end })
.collect::<Vec<S<_, 'a>>>();
- //~^ ERROR lifetime arguments must be declared prior to type arguments
+ //~^ ERROR type provided when a lifetime was expected
}
fn main() {}
-error: lifetime arguments must be declared prior to type arguments
- --> $DIR/issue-14303-fncall.rs:13:29
+error[E0747]: type provided when a lifetime was expected
+ --> $DIR/issue-14303-fncall.rs:13:26
|
LL | .collect::<Vec<S<_, 'a>>>();
- | ^^
+ | ^
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0747`.
}
fn bar<'a, 'b, 'c, T>(x: foo::X<'a, T, 'b, 'c>) {}
-//~^ ERROR lifetime arguments must be declared prior to type arguments
+//~^ ERROR type provided when a lifetime was expected
fn main() {}
-error: lifetime arguments must be declared prior to type arguments
- --> $DIR/issue-14303-path.rs:10:40
+error[E0747]: type provided when a lifetime was expected
+ --> $DIR/issue-14303-path.rs:10:37
|
LL | fn bar<'a, 'b, 'c, T>(x: foo::X<'a, T, 'b, 'c>) {}
- | ^^ ^^
+ | ^
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0747`.
struct Al<'a, T, M: OneWithLifetime<A=(), T, 'a>> {
//~^ ERROR associated type bindings must be declared after generic parameters
-//~^^ ERROR lifetime arguments must be declared prior to type arguments
+//~^^ ERROR type provided when a lifetime was expected
m: M,
t: &'a T,
}
struct Bl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<A=(), B=(), C=(), T, U, V, 'a, 'b, 'c>> {
//~^ ERROR associated type bindings must be declared after generic parameters
-//~^^ ERROR lifetime arguments must be declared prior to type arguments
+//~^^ ERROR type provided when a lifetime was expected
m: M,
t: &'a T,
u: &'b U,
struct Cl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), C=(), U, 'b, V, 'c>> {
//~^ ERROR associated type bindings must be declared after generic parameters
-//~^^ ERROR lifetime arguments must be declared prior to type arguments
+//~^^ ERROR lifetime provided when a type was expected
m: M,
t: &'a T,
u: &'b U,
struct Dl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), U, 'b, C=(), V, 'c>> {
//~^ ERROR associated type bindings must be declared after generic parameters
-//~^^ ERROR lifetime arguments must be declared prior to type arguments
+//~^^ ERROR lifetime provided when a type was expected
m: M,
t: &'a T,
u: &'b U,
| | this associated type binding should be moved after the generic parameters
| this associated type binding should be moved after the generic parameters
-error: lifetime arguments must be declared prior to type arguments
- --> $DIR/suggest-move-types.rs:34:46
+error[E0747]: type provided when a lifetime was expected
+ --> $DIR/suggest-move-types.rs:34:43
|
LL | struct Al<'a, T, M: OneWithLifetime<A=(), T, 'a>> {
- | ^^
+ | ^
-error: lifetime arguments must be declared prior to type arguments
- --> $DIR/suggest-move-types.rs:48:80
+error[E0747]: type provided when a lifetime was expected
+ --> $DIR/suggest-move-types.rs:48:71
|
LL | struct Bl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<A=(), B=(), C=(), T, U, V, 'a, 'b, 'c>> {
- | ^^ ^^ ^^
+ | ^
-error: lifetime arguments must be declared prior to type arguments
+error[E0747]: lifetime provided when a type was expected
--> $DIR/suggest-move-types.rs:64:56
|
LL | struct Cl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), C=(), U, 'b, V, 'c>> {
- | ^^ ^^ ^^
+ | ^^
-error: lifetime arguments must be declared prior to type arguments
+error[E0747]: lifetime provided when a type was expected
--> $DIR/suggest-move-types.rs:80:56
|
LL | struct Dl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), U, 'b, C=(), V, 'c>> {
- | ^^ ^^ ^^
+ | ^^
error: aborting due to 12 previous errors
+For more information about this error, try `rustc --explain E0747`.
//~^ ERROR wrong number of lifetime arguments: expected 1, found 2
//~| ERROR wrong number of type arguments: expected 1, found 0
let _: S<dyn 'static +, 'static>;
- //~^ ERROR lifetime arguments must be declared prior to type arguments
+ //~^ ERROR type provided when a lifetime was expected
//~| ERROR at least one trait is required for an object type
}
-error: lifetime arguments must be declared prior to type arguments
- --> $DIR/trait-object-vs-lifetime.rs:14:29
- |
-LL | let _: S<dyn 'static +, 'static>;
- | ^^^^^^^
-
error[E0224]: at least one trait is required for an object type
--> $DIR/trait-object-vs-lifetime.rs:9:23
|
LL | let _: S<dyn 'static +, 'static>;
| ^^^^^^^^^^^^^
+error[E0747]: type provided when a lifetime was expected
+ --> $DIR/trait-object-vs-lifetime.rs:14:14
+ |
+LL | let _: S<dyn 'static +, 'static>;
+ | ^^^^^^^^^^^^^
+
error: aborting due to 5 previous errors
-For more information about this error, try `rustc --explain E0107`.
+Some errors have detailed explanations: E0107, E0747.
+For more information about an error, try `rustc --explain E0107`.
projects / rust.git / commitdiff