1 use crate::ImplTraitPosition;
3 use super::errors::{GenericTypeWithParentheses, UseAngleBrackets};
4 use super::ResolverAstLoweringExt;
5 use super::{GenericArgsCtor, LifetimeRes, ParenthesizedGenericArgs};
6 use super::{ImplTraitContext, LoweringContext, ParamMode};
8 use rustc_ast::{self as ast, *};
10 use rustc_hir::def::{DefKind, PartialRes, Res};
11 use rustc_hir::GenericArg;
12 use rustc_span::symbol::{kw, Ident};
13 use rustc_span::{BytePos, Span, DUMMY_SP};
15 use smallvec::smallvec;
17 impl<'a, 'hir> LoweringContext<'a, 'hir> {
18 #[instrument(level = "trace", skip(self))]
19 pub(crate) fn lower_qpath(
22 qself: &Option<ptr::P<QSelf>>,
24 param_mode: ParamMode,
25 itctx: &ImplTraitContext,
26 ) -> hir::QPath<'hir> {
27 let qself_position = qself.as_ref().map(|q| q.position);
28 let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx));
31 self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err));
32 let base_res = partial_res.base_res();
33 let unresolved_segments = partial_res.unresolved_segments();
35 let path_span_lo = p.span.shrink_to_lo();
36 let proj_start = p.segments.len() - unresolved_segments;
37 let path = self.arena.alloc(hir::Path {
38 res: self.lower_res(base_res),
39 segments: self.arena.alloc_from_iter(p.segments[..proj_start].iter().enumerate().map(
41 let param_mode = match (qself_position, param_mode) {
42 (Some(j), ParamMode::Optional) if i < j => {
43 // This segment is part of the trait path in a
44 // qualified path - one of `a`, `b` or `Trait`
45 // in `<X as a::b::Trait>::T::U::method`.
51 let parenthesized_generic_args = match base_res {
52 // `a::b::Trait(Args)`
53 Res::Def(DefKind::Trait, _) if i + 1 == proj_start => {
54 ParenthesizedGenericArgs::Ok
56 // `a::b::Trait(Args)::TraitItem`
57 Res::Def(DefKind::AssocFn, _)
58 | Res::Def(DefKind::AssocConst, _)
59 | Res::Def(DefKind::AssocTy, _)
60 if i + 2 == proj_start =>
62 ParenthesizedGenericArgs::Ok
64 // Avoid duplicated errors.
65 Res::Err => ParenthesizedGenericArgs::Ok,
67 _ => ParenthesizedGenericArgs::Err,
70 self.lower_path_segment(
74 parenthesized_generic_args,
79 span: self.lower_span(
80 p.segments[..proj_start]
82 .map_or(path_span_lo, |segment| path_span_lo.to(segment.span())),
86 // Simple case, either no projections, or only fully-qualified.
87 // E.g., `std::mem::size_of` or `<I as Iterator>::Item`.
88 if unresolved_segments == 0 {
89 return hir::QPath::Resolved(qself, path);
92 // Create the innermost type that we're projecting from.
93 let mut ty = if path.segments.is_empty() {
94 // If the base path is empty that means there exists a
95 // syntactical `Self`, e.g., `&i32` in `<&i32>::clone`.
96 qself.expect("missing QSelf for <T>::...")
98 // Otherwise, the base path is an implicit `Self` type path,
99 // e.g., `Vec` in `Vec::new` or `<I as Iterator>::Item` in
100 // `<I as Iterator>::Item::default`.
101 let new_id = self.next_id();
102 self.arena.alloc(self.ty_path(new_id, path.span, hir::QPath::Resolved(qself, path)))
105 // Anything after the base path are associated "extensions",
106 // out of which all but the last one are associated types,
107 // e.g., for `std::vec::Vec::<T>::IntoIter::Item::clone`:
108 // * base path is `std::vec::Vec<T>`
109 // * "extensions" are `IntoIter`, `Item` and `clone`
111 // 1. `std::vec::Vec<T>` (created above)
112 // 2. `<std::vec::Vec<T>>::IntoIter`
113 // 3. `<<std::vec::Vec<T>>::IntoIter>::Item`
114 // * final path is `<<<std::vec::Vec<T>>::IntoIter>::Item>::clone`
115 for (i, segment) in p.segments.iter().enumerate().skip(proj_start) {
116 let hir_segment = self.arena.alloc(self.lower_path_segment(
120 ParenthesizedGenericArgs::Err,
123 let qpath = hir::QPath::TypeRelative(ty, hir_segment);
125 // It's finished, return the extension of the right node type.
126 if i == p.segments.len() - 1 {
130 // Wrap the associated extension in another type node.
131 let new_id = self.next_id();
132 ty = self.arena.alloc(self.ty_path(new_id, path_span_lo.to(segment.span()), qpath));
135 // We should've returned in the for loop above.
137 self.diagnostic().span_bug(
140 "lower_qpath: no final extension segment in {}..{}",
147 pub(crate) fn lower_path_extra(
151 param_mode: ParamMode,
152 ) -> &'hir hir::Path<'hir> {
153 self.arena.alloc(hir::Path {
155 segments: self.arena.alloc_from_iter(p.segments.iter().map(|segment| {
156 self.lower_path_segment(
160 ParenthesizedGenericArgs::Err,
161 &ImplTraitContext::Disallowed(ImplTraitPosition::Path),
164 span: self.lower_span(p.span),
168 pub(crate) fn lower_path(
172 param_mode: ParamMode,
173 ) -> &'hir hir::Path<'hir> {
174 let res = self.expect_full_res(id);
175 let res = self.lower_res(res);
176 self.lower_path_extra(res, p, param_mode)
179 pub(crate) fn lower_path_segment(
182 segment: &PathSegment,
183 param_mode: ParamMode,
184 parenthesized_generic_args: ParenthesizedGenericArgs,
185 itctx: &ImplTraitContext,
186 ) -> hir::PathSegment<'hir> {
187 debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment,);
188 let (mut generic_args, infer_args) = if let Some(generic_args) = segment.args.as_deref() {
190 GenericArgs::AngleBracketed(data) => {
191 self.lower_angle_bracketed_parameter_data(data, param_mode, itctx)
193 GenericArgs::Parenthesized(data) => match parenthesized_generic_args {
194 ParenthesizedGenericArgs::Ok => {
195 self.lower_parenthesized_parameter_data(data, itctx)
197 ParenthesizedGenericArgs::Err => {
198 // Suggest replacing parentheses with angle brackets `Trait(params...)` to `Trait<params...>`
199 let sub = if !data.inputs.is_empty() {
200 // Start of the span to the 1st character of 1st argument
201 let open_param = data.inputs_span.shrink_to_lo().to(data
207 // Last character position of last argument to the end of the span
208 let close_param = data
214 .to(data.inputs_span.shrink_to_hi());
216 Some(UseAngleBrackets { open_param, close_param })
220 self.tcx.sess.emit_err(GenericTypeWithParentheses { span: data.span, sub });
222 self.lower_angle_bracketed_parameter_data(
223 &data.as_angle_bracketed_args(),
236 args: Default::default(),
238 parenthesized: false,
239 span: path_span.shrink_to_hi(),
241 param_mode == ParamMode::Optional,
246 generic_args.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)));
247 if !generic_args.parenthesized && !has_lifetimes {
248 self.maybe_insert_elided_lifetimes_in_path(
256 let res = self.expect_full_res(segment.id);
257 let hir_id = self.lower_node_id(segment.id);
259 "lower_path_segment: ident={:?} original-id={:?} new-id={:?}",
260 segment.ident, segment.id, hir_id,
264 ident: self.lower_ident(segment.ident),
266 res: self.lower_res(res),
268 args: if generic_args.is_empty() && generic_args.span.is_empty() {
271 Some(generic_args.into_generic_args(self))
276 fn maybe_insert_elided_lifetimes_in_path(
280 segment_ident_span: Span,
281 generic_args: &mut GenericArgsCtor<'hir>,
283 let (start, end) = match self.resolver.get_lifetime_res(segment_id) {
284 Some(LifetimeRes::ElidedAnchor { start, end }) => (start, end),
288 let expected_lifetimes = end.as_usize() - start.as_usize();
289 debug!(expected_lifetimes);
291 // Note: these spans are used for diagnostics when they can't be inferred.
292 // See rustc_resolve::late::lifetimes::LifetimeContext::add_missing_lifetime_specifiers_label
293 let elided_lifetime_span = if generic_args.span.is_empty() {
294 // If there are no brackets, use the identifier span.
295 // HACK: we use find_ancestor_inside to properly suggest elided spans in paths
296 // originating from macros, since the segment's span might be from a macro arg.
297 segment_ident_span.find_ancestor_inside(path_span).unwrap_or(path_span)
298 } else if generic_args.is_empty() {
299 // If there are brackets, but not generic arguments, then use the opening bracket
300 generic_args.span.with_hi(generic_args.span.lo() + BytePos(1))
302 // Else use an empty span right after the opening bracket.
303 generic_args.span.with_lo(generic_args.span.lo() + BytePos(1)).shrink_to_lo()
306 generic_args.args.insert_many(
308 (start.as_u32()..end.as_u32()).map(|i| {
309 let id = NodeId::from_u32(i);
310 let l = self.lower_lifetime(&Lifetime {
312 ident: Ident::new(kw::Empty, elided_lifetime_span),
314 GenericArg::Lifetime(l)
319 pub(crate) fn lower_angle_bracketed_parameter_data(
321 data: &AngleBracketedArgs,
322 param_mode: ParamMode,
323 itctx: &ImplTraitContext,
324 ) -> (GenericArgsCtor<'hir>, bool) {
325 let has_non_lt_args = data.args.iter().any(|arg| match arg {
326 AngleBracketedArg::Arg(ast::GenericArg::Lifetime(_))
327 | AngleBracketedArg::Constraint(_) => false,
328 AngleBracketedArg::Arg(ast::GenericArg::Type(_) | ast::GenericArg::Const(_)) => true,
333 .filter_map(|arg| match arg {
334 AngleBracketedArg::Arg(arg) => Some(self.lower_generic_arg(arg, itctx)),
335 AngleBracketedArg::Constraint(_) => None,
338 let bindings = self.arena.alloc_from_iter(data.args.iter().filter_map(|arg| match arg {
339 AngleBracketedArg::Constraint(c) => Some(self.lower_assoc_ty_constraint(c, itctx)),
340 AngleBracketedArg::Arg(_) => None,
342 let ctor = GenericArgsCtor { args, bindings, parenthesized: false, span: data.span };
343 (ctor, !has_non_lt_args && param_mode == ParamMode::Optional)
346 fn lower_parenthesized_parameter_data(
348 data: &ParenthesizedArgs,
349 itctx: &ImplTraitContext,
350 ) -> (GenericArgsCtor<'hir>, bool) {
351 // Switch to `PassThrough` mode for anonymous lifetimes; this
352 // means that we permit things like `&Ref<T>`, where `Ref` has
353 // a hidden lifetime parameter. This is needed for backwards
354 // compatibility, even in contexts like an impl header where
355 // we generally don't permit such things (see #51008).
356 let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
357 let inputs = self.arena.alloc_from_iter(inputs.iter().map(|ty| {
358 self.lower_ty_direct(ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
360 let output_ty = match output {
361 // Only allow `impl Trait` in return position. i.e.:
363 // fn f(_: impl Fn() -> impl Debug) -> impl Fn() -> impl Debug
364 // // disallowed --^^^^^^^^^^ allowed --^^^^^^^^^^
367 if matches!(itctx, ImplTraitContext::ReturnPositionOpaqueTy { .. })
368 && self.tcx.features().impl_trait_in_fn_trait_return =>
370 self.lower_ty(&ty, itctx)
373 self.lower_ty(&ty, &ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
375 FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
377 let args = smallvec![GenericArg::Type(self.arena.alloc(self.ty_tup(*inputs_span, inputs)))];
378 let binding = self.output_ty_binding(output_ty.span, output_ty);
382 bindings: arena_vec![self; binding],
384 span: data.inputs_span,
390 /// An associated type binding `Output = $ty`.
391 pub(crate) fn output_ty_binding(
394 ty: &'hir hir::Ty<'hir>,
395 ) -> hir::TypeBinding<'hir> {
396 let ident = Ident::with_dummy_span(hir::FN_OUTPUT_NAME);
397 let kind = hir::TypeBindingKind::Equality { term: ty.into() };
398 let args = arena_vec![self;];
399 let bindings = arena_vec![self;];
400 let gen_args = self.arena.alloc(hir::GenericArgs {
403 parenthesized: false,
407 hir_id: self.next_id(),
409 span: self.lower_span(span),