compiler/rustc_typeck/src/astconv/generics.rs

   1 use super::IsMethodCall;
   2 use crate::astconv::{
   3     AstConv, CreateSubstsForGenericArgsCtxt, ExplicitLateBound, GenericArgCountMismatch,
   4     GenericArgCountResult, GenericArgPosition,
   5 };
   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};
  10 use rustc_hir as hir;
  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,
  16 };
  17 use rustc_session::lint::builtin::LATE_BOUND_LIFETIME_ARGUMENTS;
  18 use rustc_span::{symbol::kw, MultiSpan, Span};
  19 use smallvec::SmallVec;
  20
  21 impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  22     /// Report an error that a generic argument did not match the generic parameter that was
  23     /// expected.
  24     fn generic_arg_mismatch_err(
  25         tcx: TyCtxt<'_>,
  26         arg: &GenericArg<'_>,
  27         param: &GenericParamDef,
  28         possible_ordering_error: bool,
  29         help: Option<&str>,
  30     ) {
  31         let sess = tcx.sess;
  32         let mut err = struct_span_err!(
  33             sess,
  34             arg.span(),
  35             E0747,
  36             "{} provided when a {} was expected",
  37             arg.descr(),
  38             param.kind.descr(),
  39         );
  40
  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() {
  45                     err.help(
  46                         "add `#![feature(generic_arg_infer)]` to the crate attributes to enable",
  47                     );
  48                 }
  49             }
  50         }
  51
  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(" }")),
  56             ];
  57             err.multipart_suggestion(
  58                 "if this generic argument was intended as a const parameter, \
  59                  surround it with braces",
  60                 suggestions,
  61                 Applicability::MaybeIncorrect,
  62             );
  63         };
  64
  65         // Specific suggestion set for diagnostics
  66         match (arg, &param.kind) {
  67             (
  68                 GenericArg::Type(hir::Ty {
  69                     kind: hir::TyKind::Path(rustc_hir::QPath::Resolved(_, path)),
  70                     ..
  71                 }),
  72                 GenericParamDefKind::Const { .. },
  73             ) => match path.res {
  74                 Res::Err => {
  75                     add_braces_suggestion(arg, &mut err);
  76                     err.set_primary_message(
  77                         "unresolved item provided when a constant was expected",
  78                     )
  79                     .emit();
  80                     return;
  81                 }
  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() {
  88                             err.span_suggestion(
  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,
  93                             );
  94                         };
  95                     }
  96                 }
  97                 _ => add_braces_suggestion(arg, &mut err),
  98             },
  99             (
 100                 GenericArg::Type(hir::Ty { kind: hir::TyKind::Path(_), .. }),
 101                 GenericParamDefKind::Const { .. },
 102             ) => add_braces_suggestion(arg, &mut err),
 103             (
 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 {
 109                     err.span_suggestion(
 110                         arg.span(),
 111                         "array type provided where a `usize` was expected, try",
 112                         format!("{{ {} }}", snippet),
 113                         Applicability::MaybeIncorrect,
 114                     );
 115                 }
 116             }
 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)) =
 120                     body.value.kind
 121                 {
 122                     if let Res::Def(DefKind::Fn { .. }, id) = path.res {
 123                         err.help(&format!(
 124                             "`{}` is a function item, not a type",
 125                             tcx.item_name(id)
 126                         ));
 127                         err.help("function item types cannot be named directly");
 128                     }
 129                 }
 130             }
 131             _ => {}
 132         }
 133
 134         let kind_ord = param.kind.to_ord();
 135         let arg_ord = arg.to_ord();
 136
 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())
 141             } else {
 142                 (arg.descr(), param.kind.descr())
 143             };
 144             err.note(&format!("{} arguments must be provided before {} arguments", first, last));
 145             if let Some(help) = help {
 146                 err.help(help);
 147             }
 148         }
 149
 150         err.emit();
 151     }
 152
 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:
 157     ///
 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.
 164     ///
 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:
 171     ///
 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>(
 183         tcx: TyCtxt<'tcx>,
 184         def_id: DefId,
 185         parent_substs: &[subst::GenericArg<'tcx>],
 186         has_self: bool,
 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));
 200         }
 201
 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();
 209
 210             // If we have already computed substitutions for parents, we can use those directly.
 211             while let Some(&param) = params.peek() {
 212                 if let Some(&kind) = parent_substs.get(param.index as usize) {
 213                     substs.push(kind);
 214                     params.next();
 215                 } else {
 216                     break;
 217                 }
 218             }
 219
 220             // `Self` is handled first, unless it's been handled in `parent_substs`.
 221             if has_self {
 222                 if let Some(&param) = params.peek() {
 223                     if param.index == 0 {
 224                         if let GenericParamDefKind::Type { .. } = param.kind {
 225                             substs.push(
 226                                 self_ty
 227                                     .map(|ty| ty.into())
 228                                     .unwrap_or_else(|| ctx.inferred_kind(None, param, true)),
 229                             );
 230                             params.next();
 231                         }
 232                     }
 233                 }
 234             }
 235
 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);
 238
 239             let args_iter = generic_args.iter().flat_map(|generic_args| generic_args.args.iter());
 240             let mut args = args_iter.clone().peekable();
 241
 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;
 247
 248             loop {
 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(&param)) => {
 255                         match (arg, &param.kind, arg_count.explicit_late_bound) {
 256                             (GenericArg::Lifetime(_), GenericParamDefKind::Lifetime, _)
 257                             | (
 258                                 GenericArg::Type(_) | GenericArg::Infer(_),
 259                                 GenericParamDefKind::Type { .. },
 260                                 _,
 261                             )
 262                             | (
 263                                 GenericArg::Const(_) | GenericArg::Infer(_),
 264                                 GenericParamDefKind::Const { .. },
 265                                 _,
 266                             ) => {
 267                                 substs.push(ctx.provided_kind(param, arg));
 268                                 args.next();
 269                                 params.next();
 270                             }
 271                             (
 272                                 GenericArg::Infer(_) | GenericArg::Type(_) | GenericArg::Const(_),
 273                                 GenericParamDefKind::Lifetime,
 274                                 _,
 275                             ) => {
 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));
 280                                 params.next();
 281                             }
 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
 286                                 // ignore it.
 287                                 args.next();
 288                             }
 289                             (_, _, _) => {
 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
 298                                         .params
 299                                         .clone()
 300                                         .into_iter()
 301                                         .map(|param| (param.kind.to_ord(), param))
 302                                         .collect::<Vec<(ParamKindOrd, GenericParamDef)>>();
 303                                     param_types_present.sort_by_key(|(ord, _)| *ord);
 304                                     let (mut param_types_present, ordered_params): (
 305                                         Vec<ParamKindOrd>,
 306                                         Vec<GenericParamDef>,
 307                                     ) = param_types_present.into_iter().unzip();
 308                                     param_types_present.dedup();
 309
 310                                     Self::generic_arg_mismatch_err(
 311                                         tcx,
 312                                         arg,
 313                                         param,
 314                                         !args_iter.clone().is_sorted_by_key(|arg| arg.to_ord()),
 315                                         Some(&format!(
 316                                             "reorder the arguments: {}: `<{}>`",
 317                                             param_types_present
 318                                                 .into_iter()
 319                                                 .map(|ord| format!("{}s", ord))
 320                                                 .collect::<Vec<String>>()
 321                                                 .join(", then "),
 322                                             ordered_params
 323                                                 .into_iter()
 324                                                 .filter_map(|param| {
 325                                                     if param.name == kw::SelfUpper {
 326                                                         None
 327                                                     } else {
 328                                                         Some(param.name.to_string())
 329                                                     }
 330                                                 })
 331                                                 .collect::<Vec<String>>()
 332                                                 .join(", ")
 333                                         )),
 334                                     );
 335                                 }
 336
 337                                 // We've reported the error, but we want to make sure that this
 338                                 // problem doesn't bubble down and create additional, irrelevant
 339                                 // errors. In this case, we're simply going to ignore the argument
 340                                 // and any following arguments. The rest of the parameters will be
 341                                 // inferred.
 342                                 while args.next().is_some() {}
 343                             }
 344                         }
 345                     }
 346
 347                     (Some(&arg), None) => {
 348                         // We should never be able to reach this point with well-formed input.
 349                         // There are three situations in which we can encounter this issue.
 350                         //
 351                         //  1.  The number of arguments is incorrect. In this case, an error
 352                         //      will already have been emitted, and we can ignore it.
 353                         //  2.  There are late-bound lifetime parameters present, yet the
 354                         //      lifetime arguments have also been explicitly specified by the
 355                         //      user.
 356                         //  3.  We've inferred some lifetimes, which have been provided later (i.e.
 357                         //      after a type or const). We want to throw an error in this case.
 358
 359                         if arg_count.correct.is_ok()
 360                             && arg_count.explicit_late_bound == ExplicitLateBound::No
 361                         {
 362                             let kind = arg.descr();
 363                             assert_eq!(kind, "lifetime");
 364                             let (provided_arg, param) =
 365                                 force_infer_lt.expect("lifetimes ought to have been inferred");
 366                             Self::generic_arg_mismatch_err(tcx, provided_arg, param, false, None);
 367                         }
 368
 369                         break;
 370                     }
 371
 372                     (None, Some(&param)) => {
 373                         // If there are fewer arguments than parameters, it means
 374                         // we're inferring the remaining arguments.
 375                         substs.push(ctx.inferred_kind(Some(&substs), param, infer_args));
 376                         params.next();
 377                     }
 378
 379                     (None, None) => break,
 380                 }
 381             }
 382         }
 383
 384         tcx.intern_substs(&substs)
 385     }
 386
 387     /// Checks that the correct number of generic arguments have been provided.
 388     /// Used specifically for function calls.
 389     pub fn check_generic_arg_count_for_call(
 390         tcx: TyCtxt<'_>,
 391         span: Span,
 392         def_id: DefId,
 393         generics: &ty::Generics,
 394         seg: &hir::PathSegment<'_>,
 395         is_method_call: IsMethodCall,
 396     ) -> GenericArgCountResult {
 397         let empty_args = hir::GenericArgs::none();
 398         let suppress_mismatch = Self::check_impl_trait(tcx, seg, generics);
 399
 400         let gen_args = seg.args.unwrap_or(&empty_args);
 401         let gen_pos = if is_method_call == IsMethodCall::Yes {
 402             GenericArgPosition::MethodCall
 403         } else {
 404             GenericArgPosition::Value
 405         };
 406         let has_self = generics.parent.is_none() && generics.has_self;
 407         let infer_args = seg.infer_args || suppress_mismatch;
 408
 409         Self::check_generic_arg_count(
 410             tcx, span, def_id, seg, generics, gen_args, gen_pos, has_self, infer_args,
 411         )
 412     }
 413
 414     /// Checks that the correct number of generic arguments have been provided.
 415     /// This is used both for datatypes and function calls.
 416     #[instrument(skip(tcx, gen_pos), level = "debug")]
 417     pub(crate) fn check_generic_arg_count(
 418         tcx: TyCtxt<'_>,
 419         span: Span,
 420         def_id: DefId,
 421         seg: &hir::PathSegment<'_>,
 422         gen_params: &ty::Generics,
 423         gen_args: &hir::GenericArgs<'_>,
 424         gen_pos: GenericArgPosition,
 425         has_self: bool,
 426         infer_args: bool,
 427     ) -> GenericArgCountResult {
 428         let default_counts = gen_params.own_defaults();
 429         let param_counts = gen_params.own_counts();
 430
 431         // Subtracting from param count to ensure type params synthesized from `impl Trait`
 432         // cannot be explictly specified even with `explicit_generic_args_with_impl_trait`
 433         // feature enabled.
 434         let synth_type_param_count = if tcx.features().explicit_generic_args_with_impl_trait {
 435             gen_params
 436                 .params
 437                 .iter()
 438                 .filter(|param| {
 439                     matches!(param.kind, ty::GenericParamDefKind::Type { synthetic: true, .. })
 440                 })
 441                 .count()
 442         } else {
 443             0
 444         };
 445         let named_type_param_count =
 446             param_counts.types - has_self as usize - synth_type_param_count;
 447         let infer_lifetimes =
 448             gen_pos != GenericArgPosition::Type && !gen_args.has_lifetime_params();
 449
 450         if gen_pos != GenericArgPosition::Type && !gen_args.bindings.is_empty() {
 451             Self::prohibit_assoc_ty_binding(tcx, gen_args.bindings[0].span);
 452         }
 453
 454         let explicit_late_bound =
 455             Self::prohibit_explicit_late_bound_lifetimes(tcx, gen_params, gen_args, gen_pos);
 456
 457         let mut invalid_args = vec![];
 458
 459         let mut check_lifetime_args = |min_expected_args: usize,
 460                                        max_expected_args: usize,
 461                                        provided_args: usize,
 462                                        late_bounds_ignore: bool|
 463          -> bool {
 464             if (min_expected_args..=max_expected_args).contains(&provided_args) {
 465                 return true;
 466             }
 467
 468             if late_bounds_ignore {
 469                 return true;
 470             }
 471
 472             if provided_args > max_expected_args {
 473                 invalid_args.extend(
 474                     gen_args.args[max_expected_args..provided_args].iter().map(|arg| arg.span()),
 475                 );
 476             };
 477
 478             let gen_args_info = if provided_args > min_expected_args {
 479                 invalid_args.extend(
 480                     gen_args.args[min_expected_args..provided_args].iter().map(|arg| arg.span()),
 481                 );
 482                 let num_redundant_args = provided_args - min_expected_args;
 483                 GenericArgsInfo::ExcessLifetimes { num_redundant_args }
 484             } else {
 485                 let num_missing_args = min_expected_args - provided_args;
 486                 GenericArgsInfo::MissingLifetimes { num_missing_args }
 487             };
 488
 489             WrongNumberOfGenericArgs::new(
 490                 tcx,
 491                 gen_args_info,
 492                 seg,
 493                 gen_params,
 494                 has_self as usize,
 495                 gen_args,
 496                 def_id,
 497             )
 498             .diagnostic()
 499             .emit();
 500
 501             false
 502         };
 503
 504         let min_expected_lifetime_args = if infer_lifetimes { 0 } else { param_counts.lifetimes };
 505         let max_expected_lifetime_args = param_counts.lifetimes;
 506         let num_provided_lifetime_args = gen_args.num_lifetime_params();
 507
 508         let lifetimes_correct = check_lifetime_args(
 509             min_expected_lifetime_args,
 510             max_expected_lifetime_args,
 511             num_provided_lifetime_args,
 512             explicit_late_bound == ExplicitLateBound::Yes,
 513         );
 514
 515         let mut check_types_and_consts =
 516             |expected_min, expected_max, provided, params_offset, args_offset| {
 517                 debug!(
 518                     ?expected_min,
 519                     ?expected_max,
 520                     ?provided,
 521                     ?params_offset,
 522                     ?args_offset,
 523                     "check_types_and_consts"
 524                 );
 525                 if (expected_min..=expected_max).contains(&provided) {
 526                     return true;
 527                 }
 528
 529                 let num_default_params = expected_max - expected_min;
 530
 531                 let gen_args_info = if provided > expected_max {
 532                     invalid_args.extend(
 533                         gen_args.args[args_offset + expected_max..args_offset + provided]
 534                             .iter()
 535                             .map(|arg| arg.span()),
 536                     );
 537                     let num_redundant_args = provided - expected_max;
 538
 539                     GenericArgsInfo::ExcessTypesOrConsts {
 540                         num_redundant_args,
 541                         num_default_params,
 542                         args_offset,
 543                     }
 544                 } else {
 545                     let num_missing_args = expected_max - provided;
 546
 547                     GenericArgsInfo::MissingTypesOrConsts {
 548                         num_missing_args,
 549                         num_default_params,
 550                         args_offset,
 551                     }
 552                 };
 553
 554                 debug!(?gen_args_info);
 555
 556                 WrongNumberOfGenericArgs::new(
 557                     tcx,
 558                     gen_args_info,
 559                     seg,
 560                     gen_params,
 561                     params_offset,
 562                     gen_args,
 563                     def_id,
 564                 )
 565                 .diagnostic()
 566                 .emit_unless(gen_args.has_err());
 567
 568                 false
 569             };
 570
 571         let args_correct = {
 572             let expected_min = if infer_args {
 573                 0
 574             } else {
 575                 param_counts.consts + named_type_param_count
 576                     - default_counts.types
 577                     - default_counts.consts
 578             };
 579             debug!(?expected_min);
 580             debug!(arg_counts.lifetimes=?gen_args.num_lifetime_params());
 581
 582             check_types_and_consts(
 583                 expected_min,
 584                 param_counts.consts + named_type_param_count,
 585                 gen_args.num_generic_params(),
 586                 param_counts.lifetimes + has_self as usize,
 587                 gen_args.num_lifetime_params(),
 588             )
 589         };
 590
 591         GenericArgCountResult {
 592             explicit_late_bound,
 593             correct: if lifetimes_correct && args_correct {
 594                 Ok(())
 595             } else {
 596                 Err(GenericArgCountMismatch { reported: Some(ErrorReported), invalid_args })
 597             },
 598         }
 599     }
 600
 601     /// Report error if there is an explicit type parameter when using `impl Trait`.
 602     pub(crate) fn check_impl_trait(
 603         tcx: TyCtxt<'_>,
 604         seg: &hir::PathSegment<'_>,
 605         generics: &ty::Generics,
 606     ) -> bool {
 607         if seg.infer_args || tcx.features().explicit_generic_args_with_impl_trait {
 608             return false;
 609         }
 610
 611         let impl_trait = generics.has_impl_trait();
 612
 613         if impl_trait {
 614             let spans = seg
 615                 .args()
 616                 .args
 617                 .iter()
 618                 .filter_map(|arg| match arg {
 619                     GenericArg::Infer(_) | GenericArg::Type(_) | GenericArg::Const(_) => {
 620                         Some(arg.span())
 621                     }
 622                     _ => None,
 623                 })
 624                 .collect::<Vec<_>>();
 625
 626             let mut err = struct_span_err! {
 627                 tcx.sess,
 628                 spans.clone(),
 629                 E0632,
 630                 "cannot provide explicit generic arguments when `impl Trait` is \
 631                 used in argument position"
 632             };
 633
 634             for span in spans {
 635                 err.span_label(span, "explicit generic argument not allowed");
 636             }
 637
 638             err.note(
 639                 "see issue #83701 <https://github.com/rust-lang/rust/issues/83701> \
 640                  for more information",
 641             );
 642             if tcx.sess.is_nightly_build() {
 643                 err.help(
 644                     "add `#![feature(explicit_generic_args_with_impl_trait)]` \
 645                      to the crate attributes to enable",
 646                 );
 647             }
 648
 649             err.emit();
 650         }
 651
 652         impl_trait
 653     }
 654
 655     /// Emits an error regarding forbidden type binding associations
 656     pub fn prohibit_assoc_ty_binding(tcx: TyCtxt<'_>, span: Span) {
 657         tcx.sess.emit_err(AssocTypeBindingNotAllowed { span });
 658     }
 659
 660     /// Prohibits explicit lifetime arguments if late-bound lifetime parameters
 661     /// are present. This is used both for datatypes and function calls.
 662     pub(crate) fn prohibit_explicit_late_bound_lifetimes(
 663         tcx: TyCtxt<'_>,
 664         def: &ty::Generics,
 665         args: &hir::GenericArgs<'_>,
 666         position: GenericArgPosition,
 667     ) -> ExplicitLateBound {
 668         let param_counts = def.own_counts();
 669         let infer_lifetimes = position != GenericArgPosition::Type && !args.has_lifetime_params();
 670
 671         if infer_lifetimes {
 672             return ExplicitLateBound::No;
 673         }
 674
 675         if let Some(span_late) = def.has_late_bound_regions {
 676             let msg = "cannot specify lifetime arguments explicitly \
 677                        if late bound lifetime parameters are present";
 678             let note = "the late bound lifetime parameter is introduced here";
 679             let span = args.args[0].span();
 680
 681             if position == GenericArgPosition::Value
 682                 && args.num_lifetime_params() != param_counts.lifetimes
 683             {
 684                 let mut err = tcx.sess.struct_span_err(span, msg);
 685                 err.span_note(span_late, note);
 686                 err.emit();
 687             } else {
 688                 let mut multispan = MultiSpan::from_span(span);
 689                 multispan.push_span_label(span_late, note.to_string());
 690                 tcx.struct_span_lint_hir(
 691                     LATE_BOUND_LIFETIME_ARGUMENTS,
 692                     args.args[0].id(),
 693                     multispan,
 694                     |lint| lint.build(msg).emit(),
 695                 );
 696             }
 697
 698             ExplicitLateBound::Yes
 699         } else {
 700             ExplicitLateBound::No
 701         }
 702     }
 703 }