1 use super::IsMethodCall;
3 AstConv, CreateSubstsForGenericArgsCtxt, ExplicitLateBound, GenericArgCountMismatch,
4 GenericArgCountResult, GenericArgPosition,
6 use crate::errors::AssocTypeBindingNotAllowed;
7 use crate::structured_errors::{GenericArgsInfo, StructuredDiagnostic, WrongNumberOfGenericArgs};
8 use rustc_ast::ast::ParamKindOrd;
9 use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported};
11 use rustc_hir::def::{DefKind, Res};
12 use rustc_hir::def_id::DefId;
13 use rustc_hir::GenericArg;
14 use rustc_middle::ty::{
15 self, subst, subst::SubstsRef, GenericParamDef, GenericParamDefKind, Ty, TyCtxt,
17 use rustc_session::lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS;
18 use rustc_span::{symbol::kw, MultiSpan, Span};
19 use smallvec::SmallVec;
21 impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
22 /// Report an error that a generic argument did not match the generic parameter that was
24 fn generic_arg_mismatch_err(
27 param: &GenericParamDef,
28 possible_ordering_error: bool,
32 let mut err = struct_span_err!(
36 "{} provided when a {} was expected",
41 if let GenericParamDefKind::Const { .. } = param.kind {
42 if matches!(arg, GenericArg::Type(hir::Ty { kind: hir::TyKind::Infer, .. })) {
43 err.help("const arguments cannot yet be inferred with `_`");
44 if sess.is_nightly_build() {
46 "add `#![feature(generic_arg_infer)]` to the crate attributes to enable",
52 let add_braces_suggestion = |arg: &GenericArg<'_>, err: &mut DiagnosticBuilder<'_>| {
53 let suggestions = vec![
54 (arg.span().shrink_to_lo(), String::from("{ ")),
55 (arg.span().shrink_to_hi(), String::from(" }")),
57 err.multipart_suggestion(
58 "if this generic argument was intended as a const parameter, \
59 surround it with braces",
61 Applicability::MaybeIncorrect,
65 // Specific suggestion set for diagnostics
66 match (arg, ¶m.kind) {
68 GenericArg::Type(hir::Ty {
69 kind: hir::TyKind::Path(rustc_hir::QPath::Resolved(_, path)),
72 GenericParamDefKind::Const { .. },
75 add_braces_suggestion(arg, &mut err);
76 err.set_primary_message(
77 "unresolved item provided when a constant was expected",
82 Res::Def(DefKind::TyParam, src_def_id) => {
83 if let Some(param_local_id) = param.def_id.as_local() {
84 let param_hir_id = tcx.hir().local_def_id_to_hir_id(param_local_id);
85 let param_name = tcx.hir().ty_param_name(param_hir_id);
86 let param_type = tcx.type_of(param.def_id);
87 if param_type.is_suggestable() {
89 tcx.def_span(src_def_id),
90 "consider changing this type parameter to be a `const` generic",
91 format!("const {}: {}", param_name, param_type),
92 Applicability::MaybeIncorrect,
97 _ => add_braces_suggestion(arg, &mut err),
100 GenericArg::Type(hir::Ty { kind: hir::TyKind::Path(_), .. }),
101 GenericParamDefKind::Const { .. },
102 ) => add_braces_suggestion(arg, &mut err),
104 GenericArg::Type(hir::Ty { kind: hir::TyKind::Array(_, len), .. }),
105 GenericParamDefKind::Const { .. },
106 ) if tcx.type_of(param.def_id) == tcx.types.usize => {
107 let snippet = sess.source_map().span_to_snippet(tcx.hir().span(len.hir_id));
108 if let Ok(snippet) = snippet {
111 "array type provided where a `usize` was expected, try",
112 format!("{{ {} }}", snippet),
113 Applicability::MaybeIncorrect,
117 (GenericArg::Const(cnst), GenericParamDefKind::Type { .. }) => {
118 let body = tcx.hir().body(cnst.value.body);
119 if let rustc_hir::ExprKind::Path(rustc_hir::QPath::Resolved(_, path)) =
122 if let Res::Def(DefKind::Fn { .. }, id) = path.res {
124 "`{}` is a function item, not a type",
127 err.help("function item types cannot be named directly");
134 let kind_ord = param.kind.to_ord(tcx);
135 let arg_ord = arg.to_ord(&tcx.features());
137 // This note is only true when generic parameters are strictly ordered by their kind.
138 if possible_ordering_error && kind_ord.cmp(&arg_ord) != core::cmp::Ordering::Equal {
139 let (first, last) = if kind_ord < arg_ord {
140 (param.kind.descr(), arg.descr())
142 (arg.descr(), param.kind.descr())
144 err.note(&format!("{} arguments must be provided before {} arguments", first, last));
145 if let Some(help) = help {
153 /// Creates the relevant generic argument substitutions
154 /// corresponding to a set of generic parameters. This is a
155 /// rather complex function. Let us try to explain the role
156 /// of each of its parameters:
158 /// To start, we are given the `def_id` of the thing we are
159 /// creating the substitutions for, and a partial set of
160 /// substitutions `parent_substs`. In general, the substitutions
161 /// for an item begin with substitutions for all the "parents" of
162 /// that item -- e.g., for a method it might include the
163 /// parameters from the impl.
165 /// Therefore, the method begins by walking down these parents,
166 /// starting with the outermost parent and proceed inwards until
167 /// it reaches `def_id`. For each parent `P`, it will check `parent_substs`
168 /// first to see if the parent's substitutions are listed in there. If so,
169 /// we can append those and move on. Otherwise, it invokes the
170 /// three callback functions:
172 /// - `args_for_def_id`: given the `DefId` `P`, supplies back the
173 /// generic arguments that were given to that parent from within
174 /// the path; so e.g., if you have `<T as Foo>::Bar`, the `DefId`
175 /// might refer to the trait `Foo`, and the arguments might be
176 /// `[T]`. The boolean value indicates whether to infer values
177 /// for arguments whose values were not explicitly provided.
178 /// - `provided_kind`: given the generic parameter and the value from `args_for_def_id`,
179 /// instantiate a `GenericArg`.
180 /// - `inferred_kind`: if no parameter was provided, and inference is enabled, then
181 /// creates a suitable inference variable.
182 pub fn create_substs_for_generic_args<'a>(
185 parent_substs: &[subst::GenericArg<'tcx>],
187 self_ty: Option<Ty<'tcx>>,
188 arg_count: &GenericArgCountResult,
189 ctx: &mut impl CreateSubstsForGenericArgsCtxt<'a, 'tcx>,
190 ) -> SubstsRef<'tcx> {
191 // Collect the segments of the path; we need to substitute arguments
192 // for parameters throughout the entire path (wherever there are
193 // generic parameters).
194 let mut parent_defs = tcx.generics_of(def_id);
195 let count = parent_defs.count();
196 let mut stack = vec![(def_id, parent_defs)];
197 while let Some(def_id) = parent_defs.parent {
198 parent_defs = tcx.generics_of(def_id);
199 stack.push((def_id, parent_defs));
202 // We manually build up the substitution, rather than using convenience
203 // methods in `subst.rs`, so that we can iterate over the arguments and
204 // parameters in lock-step linearly, instead of trying to match each pair.
205 let mut substs: SmallVec<[subst::GenericArg<'tcx>; 8]> = SmallVec::with_capacity(count);
206 // Iterate over each segment of the path.
207 while let Some((def_id, defs)) = stack.pop() {
208 let mut params = defs.params.iter().peekable();
210 // If we have already computed substitutions for parents, we can use those directly.
211 while let Some(¶m) = params.peek() {
212 if let Some(&kind) = parent_substs.get(param.index as usize) {
220 // `Self` is handled first, unless it's been handled in `parent_substs`.
222 if let Some(¶m) = params.peek() {
223 if param.index == 0 {
224 if let GenericParamDefKind::Type { .. } = param.kind {
228 .unwrap_or_else(|| ctx.inferred_kind(None, param, true)),
236 // Check whether this segment takes generic arguments and the user has provided any.
237 let (generic_args, infer_args) = ctx.args_for_def_id(def_id);
239 let args_iter = generic_args.iter().flat_map(|generic_args| generic_args.args.iter());
240 let mut args = args_iter.clone().peekable();
242 // If we encounter a type or const when we expect a lifetime, we infer the lifetimes.
243 // If we later encounter a lifetime, we know that the arguments were provided in the
244 // wrong order. `force_infer_lt` records the type or const that forced lifetimes to be
245 // inferred, so we can use it for diagnostics later.
246 let mut force_infer_lt = None;
249 // We're going to iterate through the generic arguments that the user
250 // provided, matching them with the generic parameters we expect.
251 // Mismatches can occur as a result of elided lifetimes, or for malformed
252 // input. We try to handle both sensibly.
253 match (args.peek(), params.peek()) {
254 (Some(&arg), Some(¶m)) => {
255 match (arg, ¶m.kind, arg_count.explicit_late_bound) {
256 (GenericArg::Lifetime(_), GenericParamDefKind::Lifetime, _)
258 GenericArg::Type(_) | GenericArg::Infer(_),
259 GenericParamDefKind::Type { .. },
263 GenericArg::Const(_) | GenericArg::Infer(_),
264 GenericParamDefKind::Const { .. },
267 substs.push(ctx.provided_kind(param, arg));
272 GenericArg::Infer(_) | GenericArg::Type(_) | GenericArg::Const(_),
273 GenericParamDefKind::Lifetime,
276 // We expected a lifetime argument, but got a type or const
277 // argument. That means we're inferring the lifetimes.
278 substs.push(ctx.inferred_kind(None, param, infer_args));
279 force_infer_lt = Some((arg, param));
282 (GenericArg::Lifetime(_), _, ExplicitLateBound::Yes) => {
283 // We've come across a lifetime when we expected something else in
284 // the presence of explicit late bounds. This is most likely
285 // due to the presence of the explicit bound so we're just going to
290 // We expected one kind of parameter, but the user provided
291 // another. This is an error. However, if we already know that
292 // the arguments don't match up with the parameters, we won't issue
293 // an additional error, as the user already knows what's wrong.
294 if arg_count.correct.is_ok() {
295 // We're going to iterate over the parameters to sort them out, and
296 // show that order to the user as a possible order for the parameters
297 let mut param_types_present = defs
304 GenericParamDefKind::Lifetime => {
305 ParamKindOrd::Lifetime
307 GenericParamDefKind::Type { .. } => {
310 GenericParamDefKind::Const { .. } => {
311 ParamKindOrd::Const {
314 .unordered_const_ty_params(),
321 .collect::<Vec<(ParamKindOrd, GenericParamDef)>>();
322 param_types_present.sort_by_key(|(ord, _)| *ord);
323 let (mut param_types_present, ordered_params): (
325 Vec<GenericParamDef>,
326 ) = param_types_present.into_iter().unzip();
327 param_types_present.dedup();
329 Self::generic_arg_mismatch_err(
333 !args_iter.clone().is_sorted_by_key(|arg| match arg {
334 GenericArg::Lifetime(_) => ParamKindOrd::Lifetime,
335 GenericArg::Type(_) => ParamKindOrd::Type,
336 GenericArg::Const(_) => ParamKindOrd::Const {
339 .unordered_const_ty_params(),
341 GenericArg::Infer(_) => ParamKindOrd::Infer,
344 "reorder the arguments: {}: `<{}>`",
347 .map(|ord| format!("{}s", ord.to_string()))
348 .collect::<Vec<String>>()
352 .filter_map(|param| {
353 if param.name == kw::SelfUpper {
356 Some(param.name.to_string())
359 .collect::<Vec<String>>()
365 // We've reported the error, but we want to make sure that this
366 // problem doesn't bubble down and create additional, irrelevant
367 // errors. In this case, we're simply going to ignore the argument
368 // and any following arguments. The rest of the parameters will be
370 while args.next().is_some() {}
375 (Some(&arg), None) => {
376 // We should never be able to reach this point with well-formed input.
377 // There are three situations in which we can encounter this issue.
379 // 1. The number of arguments is incorrect. In this case, an error
380 // will already have been emitted, and we can ignore it.
381 // 2. There are late-bound lifetime parameters present, yet the
382 // lifetime arguments have also been explicitly specified by the
384 // 3. We've inferred some lifetimes, which have been provided later (i.e.
385 // after a type or const). We want to throw an error in this case.
387 if arg_count.correct.is_ok()
388 && arg_count.explicit_late_bound == ExplicitLateBound::No
390 let kind = arg.descr();
391 assert_eq!(kind, "lifetime");
392 let (provided_arg, param) =
393 force_infer_lt.expect("lifetimes ought to have been inferred");
394 Self::generic_arg_mismatch_err(tcx, provided_arg, param, false, None);
400 (None, Some(¶m)) => {
401 // If there are fewer arguments than parameters, it means
402 // we're inferring the remaining arguments.
403 substs.push(ctx.inferred_kind(Some(&substs), param, infer_args));
407 (None, None) => break,
412 tcx.intern_substs(&substs)
415 /// Checks that the correct number of generic arguments have been provided.
416 /// Used specifically for function calls.
417 pub fn check_generic_arg_count_for_call(
421 generics: &ty::Generics,
422 seg: &hir::PathSegment<'_>,
423 is_method_call: IsMethodCall,
424 ) -> GenericArgCountResult {
425 let empty_args = hir::GenericArgs::none();
426 let suppress_mismatch = Self::check_impl_trait(tcx, seg, &generics);
428 let gen_args = seg.args.unwrap_or(&empty_args);
429 let gen_pos = if is_method_call == IsMethodCall::Yes {
430 GenericArgPosition::MethodCall
432 GenericArgPosition::Value
434 let has_self = generics.parent.is_none() && generics.has_self;
435 let infer_args = seg.infer_args || suppress_mismatch;
437 Self::check_generic_arg_count(
438 tcx, span, def_id, seg, generics, gen_args, gen_pos, has_self, infer_args,
442 /// Checks that the correct number of generic arguments have been provided.
443 /// This is used both for datatypes and function calls.
444 pub(crate) fn check_generic_arg_count(
448 seg: &hir::PathSegment<'_>,
449 gen_params: &ty::Generics,
450 gen_args: &hir::GenericArgs<'_>,
451 gen_pos: GenericArgPosition,
454 ) -> GenericArgCountResult {
456 "check_generic_arg_count(span: {:?}, def_id: {:?}, seg: {:?}, gen_params: {:?}, gen_args: {:?})",
457 span, def_id, seg, gen_params, gen_args
460 let default_counts = gen_params.own_defaults();
461 let param_counts = gen_params.own_counts();
463 // Subtracting from param count to ensure type params synthesized from `impl Trait`
464 // cannot be explictly specified even with `explicit_generic_args_with_impl_trait`
466 let synth_type_param_count = if tcx.features().explicit_generic_args_with_impl_trait {
473 ty::GenericParamDefKind::Type {
475 hir::SyntheticTyParamKind::ImplTrait
476 | hir::SyntheticTyParamKind::FromAttr
486 let named_type_param_count =
487 param_counts.types - has_self as usize - synth_type_param_count;
488 let infer_lifetimes =
489 gen_pos != GenericArgPosition::Type && !gen_args.has_lifetime_params();
491 if gen_pos != GenericArgPosition::Type && !gen_args.bindings.is_empty() {
492 Self::prohibit_assoc_ty_binding(tcx, gen_args.bindings[0].span);
495 let explicit_late_bound =
496 Self::prohibit_explicit_late_bound_lifetimes(tcx, gen_params, gen_args, gen_pos);
498 let mut invalid_args = vec![];
500 let mut check_lifetime_args = |min_expected_args: usize,
501 max_expected_args: usize,
502 provided_args: usize,
503 late_bounds_ignore: bool|
505 if (min_expected_args..=max_expected_args).contains(&provided_args) {
509 if late_bounds_ignore {
513 if provided_args > max_expected_args {
515 gen_args.args[max_expected_args..provided_args].iter().map(|arg| arg.span()),
519 let gen_args_info = if provided_args > min_expected_args {
521 gen_args.args[min_expected_args..provided_args].iter().map(|arg| arg.span()),
523 let num_redundant_args = provided_args - min_expected_args;
524 GenericArgsInfo::ExcessLifetimes { num_redundant_args }
526 let num_missing_args = min_expected_args - provided_args;
527 GenericArgsInfo::MissingLifetimes { num_missing_args }
530 WrongNumberOfGenericArgs::new(
545 let min_expected_lifetime_args = if infer_lifetimes { 0 } else { param_counts.lifetimes };
546 let max_expected_lifetime_args = param_counts.lifetimes;
547 let num_provided_lifetime_args = gen_args.num_lifetime_params();
549 let lifetimes_correct = check_lifetime_args(
550 min_expected_lifetime_args,
551 max_expected_lifetime_args,
552 num_provided_lifetime_args,
553 explicit_late_bound == ExplicitLateBound::Yes,
556 let mut check_types_and_consts =
557 |expected_min, expected_max, provided, params_offset, args_offset| {
559 "check_types_and_consts(expected_min: {:?}, expected_max: {:?}, \
560 provided: {:?}, params_offset: {:?}, args_offset: {:?}",
561 expected_min, expected_max, provided, params_offset, args_offset
563 if (expected_min..=expected_max).contains(&provided) {
567 let num_default_params = expected_max - expected_min;
569 let gen_args_info = if provided > expected_max {
571 gen_args.args[args_offset + expected_max..args_offset + provided]
573 .map(|arg| arg.span()),
575 let num_redundant_args = provided - expected_max;
577 GenericArgsInfo::ExcessTypesOrConsts {
583 let num_missing_args = expected_max - provided;
585 GenericArgsInfo::MissingTypesOrConsts {
592 debug!("gen_args_info: {:?}", gen_args_info);
594 WrongNumberOfGenericArgs::new(
610 let expected_min = if infer_args {
613 param_counts.consts + named_type_param_count
614 - default_counts.types
615 - default_counts.consts
616 - synth_type_param_count
618 debug!("expected_min: {:?}", expected_min);
619 debug!("arg_counts.lifetimes: {:?}", gen_args.num_lifetime_params());
621 check_types_and_consts(
623 param_counts.consts + named_type_param_count,
624 gen_args.num_generic_params(),
625 param_counts.lifetimes + has_self as usize,
626 gen_args.num_lifetime_params(),
630 GenericArgCountResult {
632 correct: if lifetimes_correct && args_correct {
635 Err(GenericArgCountMismatch { reported: Some(ErrorReported), invalid_args })
640 /// Report error if there is an explicit type parameter when using `impl Trait`.
641 pub(crate) fn check_impl_trait(
643 seg: &hir::PathSegment<'_>,
644 generics: &ty::Generics,
646 if seg.infer_args || tcx.features().explicit_generic_args_with_impl_trait {
650 let impl_trait = generics.params.iter().any(|param| {
653 ty::GenericParamDefKind::Type {
655 hir::SyntheticTyParamKind::ImplTrait | hir::SyntheticTyParamKind::FromAttr,
667 .filter_map(|arg| match arg {
668 GenericArg::Infer(_) | GenericArg::Type(_) | GenericArg::Const(_) => {
673 .collect::<Vec<_>>();
675 let mut err = struct_span_err! {
679 "cannot provide explicit generic arguments when `impl Trait` is \
680 used in argument position"
684 err.span_label(span, "explicit generic argument not allowed");
693 /// Emits an error regarding forbidden type binding associations
694 pub fn prohibit_assoc_ty_binding(tcx: TyCtxt<'_>, span: Span) {
695 tcx.sess.emit_err(AssocTypeBindingNotAllowed { span });
698 /// Prohibits explicit lifetime arguments if late-bound lifetime parameters
699 /// are present. This is used both for datatypes and function calls.
700 pub(crate) fn prohibit_explicit_late_bound_lifetimes(
703 args: &hir::GenericArgs<'_>,
704 position: GenericArgPosition,
705 ) -> ExplicitLateBound {
706 let param_counts = def.own_counts();
707 let infer_lifetimes = position != GenericArgPosition::Type && !args.has_lifetime_params();
710 return ExplicitLateBound::No;
713 if let Some(span_late) = def.has_late_bound_regions {
714 let msg = "cannot specify lifetime arguments explicitly \
715 if late bound lifetime parameters are present";
716 let note = "the late bound lifetime parameter is introduced here";
717 let span = args.args[0].span();
719 if position == GenericArgPosition::Value
720 && args.num_lifetime_params() != param_counts.lifetimes
722 let mut err = tcx.sess.struct_span_err(span, msg);
723 err.span_note(span_late, note);
726 let mut multispan = MultiSpan::from_span(span);
727 multispan.push_span_label(span_late, note.to_string());
728 tcx.struct_span_lint_hir(
729 LATE_BOUND_LIFETIME_ARGUMENTS,
732 |lint| lint.build(msg).emit(),
736 ExplicitLateBound::Yes
738 ExplicitLateBound::No