8d2c63f514
`hir::Lifetime::ident` currently sometimes uses `kw::Empty` for elided lifetimes and sometimes uses `kw::UnderscoreLifetime`, and the distinction is used when creating some error suggestions, e.g. in `Lifetime::suggestion` and `ImplicitLifetimeFinder::visit_ty`. I found this *really* confusing, and it took me a while to understand what was going on. This commit replaces all uses of `kw::Empty` in `hir::Lifetime::ident` with `kw::UnderscoreLifetime`. It adds a new field `hir::Lifetime::is_path_anon` that mostly replaces the old empty/underscore distinction and makes things much clearer. Some other notable changes: - Adds a big comment to `Lifetime` talking about permissable field values. - Adds some assertions in `new_named_lifetime` about what ident values are permissible for the different `LifetimeRes` values. - Adds a `Lifetime::new` constructor that does some checking to make sure the `is_elided` and `is_anonymous` states are valid. - `add_static_impl_trait_suggestion` now looks at `Lifetime::res` instead of the ident when creating the suggestion. This is the one case where `is_path_anon` doesn't replace the old empty/underscore distinction. - A couple of minor pretty-printing improvements.
604 lines
25 KiB
Rust
604 lines
25 KiB
Rust
use std::sync::Arc;
|
|
|
|
use rustc_ast::{self as ast, *};
|
|
use rustc_hir as hir;
|
|
use rustc_hir::GenericArg;
|
|
use rustc_hir::def::{DefKind, PartialRes, Res};
|
|
use rustc_hir::def_id::DefId;
|
|
use rustc_middle::span_bug;
|
|
use rustc_session::parse::add_feature_diagnostics;
|
|
use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
|
|
use smallvec::{SmallVec, smallvec};
|
|
use tracing::{debug, instrument};
|
|
|
|
use super::errors::{
|
|
AsyncBoundNotOnTrait, AsyncBoundOnlyForFnTraits, BadReturnTypeNotation,
|
|
GenericTypeWithParentheses, RTNSuggestion, UseAngleBrackets,
|
|
};
|
|
use super::{
|
|
AllowReturnTypeNotation, GenericArgsCtor, GenericArgsMode, ImplTraitContext, ImplTraitPosition,
|
|
LifetimeRes, LoweringContext, ParamMode, ResolverAstLoweringExt,
|
|
};
|
|
|
|
impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
|
#[instrument(level = "trace", skip(self))]
|
|
pub(crate) fn lower_qpath(
|
|
&mut self,
|
|
id: NodeId,
|
|
qself: &Option<ptr::P<QSelf>>,
|
|
p: &Path,
|
|
param_mode: ParamMode,
|
|
allow_return_type_notation: AllowReturnTypeNotation,
|
|
itctx: ImplTraitContext,
|
|
// modifiers of the impl/bound if this is a trait path
|
|
modifiers: Option<ast::TraitBoundModifiers>,
|
|
) -> hir::QPath<'hir> {
|
|
let qself_position = qself.as_ref().map(|q| q.position);
|
|
let qself = qself
|
|
.as_ref()
|
|
// Reject cases like `<impl Trait>::Assoc` and `<impl Trait as Trait>::Assoc`.
|
|
.map(|q| self.lower_ty(&q.ty, ImplTraitContext::Disallowed(ImplTraitPosition::Path)));
|
|
|
|
let partial_res =
|
|
self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err));
|
|
let base_res = partial_res.base_res();
|
|
let unresolved_segments = partial_res.unresolved_segments();
|
|
|
|
let mut res = self.lower_res(base_res);
|
|
|
|
// When we have an `async` kw on a bound, map the trait it resolves to.
|
|
if let Some(TraitBoundModifiers { asyncness: BoundAsyncness::Async(_), .. }) = modifiers {
|
|
match res {
|
|
Res::Def(DefKind::Trait, def_id) => {
|
|
if let Some(async_def_id) = self.map_trait_to_async_trait(def_id) {
|
|
res = Res::Def(DefKind::Trait, async_def_id);
|
|
} else {
|
|
self.dcx().emit_err(AsyncBoundOnlyForFnTraits { span: p.span });
|
|
}
|
|
}
|
|
Res::Err => {
|
|
// No additional error.
|
|
}
|
|
_ => {
|
|
// This error isn't actually emitted AFAICT, but it's best to keep
|
|
// it around in case the resolver doesn't always check the defkind
|
|
// of an item or something.
|
|
self.dcx().emit_err(AsyncBoundNotOnTrait { span: p.span, descr: res.descr() });
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ungate the `async_fn_traits` feature in the path if the trait is
|
|
// named via either `async Fn*()` or `AsyncFn*()`.
|
|
let bound_modifier_allowed_features = if let Res::Def(DefKind::Trait, async_def_id) = res
|
|
&& self.tcx.async_fn_trait_kind_from_def_id(async_def_id).is_some()
|
|
{
|
|
Some(Arc::clone(&self.allow_async_fn_traits))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
// Only permit `impl Trait` in the final segment. E.g., we permit `Option<impl Trait>`,
|
|
// `option::Option<T>::Xyz<impl Trait>` and reject `option::Option<impl Trait>::Xyz`.
|
|
let itctx = |i| {
|
|
if i + 1 == p.segments.len() {
|
|
itctx
|
|
} else {
|
|
ImplTraitContext::Disallowed(ImplTraitPosition::Path)
|
|
}
|
|
};
|
|
|
|
let path_span_lo = p.span.shrink_to_lo();
|
|
let proj_start = p.segments.len() - unresolved_segments;
|
|
let path = self.arena.alloc(hir::Path {
|
|
res,
|
|
segments: self.arena.alloc_from_iter(p.segments[..proj_start].iter().enumerate().map(
|
|
|(i, segment)| {
|
|
let param_mode = match (qself_position, param_mode) {
|
|
(Some(j), ParamMode::Optional) if i < j => {
|
|
// This segment is part of the trait path in a
|
|
// qualified path - one of `a`, `b` or `Trait`
|
|
// in `<X as a::b::Trait>::T::U::method`.
|
|
ParamMode::Explicit
|
|
}
|
|
_ => param_mode,
|
|
};
|
|
|
|
let generic_args_mode = match base_res {
|
|
// `a::b::Trait(Args)`
|
|
Res::Def(DefKind::Trait, _) if i + 1 == proj_start => {
|
|
GenericArgsMode::ParenSugar
|
|
}
|
|
// `a::b::Trait(Args)::TraitItem`
|
|
Res::Def(DefKind::AssocFn, _)
|
|
| Res::Def(DefKind::AssocConst, _)
|
|
| Res::Def(DefKind::AssocTy, _)
|
|
if i + 2 == proj_start =>
|
|
{
|
|
GenericArgsMode::ParenSugar
|
|
}
|
|
Res::Def(DefKind::AssocFn, _) if i + 1 == proj_start => {
|
|
match allow_return_type_notation {
|
|
AllowReturnTypeNotation::Yes => GenericArgsMode::ReturnTypeNotation,
|
|
AllowReturnTypeNotation::No => GenericArgsMode::Err,
|
|
}
|
|
}
|
|
// Avoid duplicated errors.
|
|
Res::Err => GenericArgsMode::Silence,
|
|
// An error
|
|
_ => GenericArgsMode::Err,
|
|
};
|
|
|
|
self.lower_path_segment(
|
|
p.span,
|
|
segment,
|
|
param_mode,
|
|
generic_args_mode,
|
|
itctx(i),
|
|
bound_modifier_allowed_features.clone(),
|
|
)
|
|
},
|
|
)),
|
|
span: self.lower_span(
|
|
p.segments[..proj_start]
|
|
.last()
|
|
.map_or(path_span_lo, |segment| path_span_lo.to(segment.span())),
|
|
),
|
|
});
|
|
|
|
if let Some(bound_modifier_allowed_features) = bound_modifier_allowed_features {
|
|
path.span = self.mark_span_with_reason(
|
|
DesugaringKind::BoundModifier,
|
|
path.span,
|
|
Some(bound_modifier_allowed_features),
|
|
);
|
|
}
|
|
|
|
// Simple case, either no projections, or only fully-qualified.
|
|
// E.g., `std::mem::size_of` or `<I as Iterator>::Item`.
|
|
if unresolved_segments == 0 {
|
|
return hir::QPath::Resolved(qself, path);
|
|
}
|
|
|
|
// Create the innermost type that we're projecting from.
|
|
let mut ty = if path.segments.is_empty() {
|
|
// If the base path is empty that means there exists a
|
|
// syntactical `Self`, e.g., `&i32` in `<&i32>::clone`.
|
|
qself.expect("missing QSelf for <T>::...")
|
|
} else {
|
|
// Otherwise, the base path is an implicit `Self` type path,
|
|
// e.g., `Vec` in `Vec::new` or `<I as Iterator>::Item` in
|
|
// `<I as Iterator>::Item::default`.
|
|
let new_id = self.next_id();
|
|
self.arena.alloc(self.ty_path(new_id, path.span, hir::QPath::Resolved(qself, path)))
|
|
};
|
|
|
|
// Anything after the base path are associated "extensions",
|
|
// out of which all but the last one are associated types,
|
|
// e.g., for `std::vec::Vec::<T>::IntoIter::Item::clone`:
|
|
// * base path is `std::vec::Vec<T>`
|
|
// * "extensions" are `IntoIter`, `Item` and `clone`
|
|
// * type nodes are:
|
|
// 1. `std::vec::Vec<T>` (created above)
|
|
// 2. `<std::vec::Vec<T>>::IntoIter`
|
|
// 3. `<<std::vec::Vec<T>>::IntoIter>::Item`
|
|
// * final path is `<<<std::vec::Vec<T>>::IntoIter>::Item>::clone`
|
|
for (i, segment) in p.segments.iter().enumerate().skip(proj_start) {
|
|
// If this is a type-dependent `T::method(..)`.
|
|
let generic_args_mode = if i + 1 == p.segments.len()
|
|
&& matches!(allow_return_type_notation, AllowReturnTypeNotation::Yes)
|
|
{
|
|
GenericArgsMode::ReturnTypeNotation
|
|
} else {
|
|
GenericArgsMode::Err
|
|
};
|
|
|
|
let hir_segment = self.arena.alloc(self.lower_path_segment(
|
|
p.span,
|
|
segment,
|
|
param_mode,
|
|
generic_args_mode,
|
|
itctx(i),
|
|
None,
|
|
));
|
|
let qpath = hir::QPath::TypeRelative(ty, hir_segment);
|
|
|
|
// It's finished, return the extension of the right node type.
|
|
if i == p.segments.len() - 1 {
|
|
return qpath;
|
|
}
|
|
|
|
// Wrap the associated extension in another type node.
|
|
let new_id = self.next_id();
|
|
ty = self.arena.alloc(self.ty_path(new_id, path_span_lo.to(segment.span()), qpath));
|
|
}
|
|
|
|
// We should've returned in the for loop above.
|
|
|
|
self.dcx().span_bug(
|
|
p.span,
|
|
format!(
|
|
"lower_qpath: no final extension segment in {}..{}",
|
|
proj_start,
|
|
p.segments.len()
|
|
),
|
|
);
|
|
}
|
|
|
|
pub(crate) fn lower_use_path(
|
|
&mut self,
|
|
res: SmallVec<[Res; 3]>,
|
|
p: &Path,
|
|
param_mode: ParamMode,
|
|
) -> &'hir hir::UsePath<'hir> {
|
|
assert!((1..=3).contains(&res.len()));
|
|
self.arena.alloc(hir::UsePath {
|
|
res,
|
|
segments: self.arena.alloc_from_iter(p.segments.iter().map(|segment| {
|
|
self.lower_path_segment(
|
|
p.span,
|
|
segment,
|
|
param_mode,
|
|
GenericArgsMode::Err,
|
|
ImplTraitContext::Disallowed(ImplTraitPosition::Path),
|
|
None,
|
|
)
|
|
})),
|
|
span: self.lower_span(p.span),
|
|
})
|
|
}
|
|
|
|
pub(crate) fn lower_path_segment(
|
|
&mut self,
|
|
path_span: Span,
|
|
segment: &PathSegment,
|
|
param_mode: ParamMode,
|
|
generic_args_mode: GenericArgsMode,
|
|
itctx: ImplTraitContext,
|
|
// Additional features ungated with a bound modifier like `async`.
|
|
// This is passed down to the implicit associated type binding in
|
|
// parenthesized bounds.
|
|
bound_modifier_allowed_features: Option<Arc<[Symbol]>>,
|
|
) -> hir::PathSegment<'hir> {
|
|
debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment);
|
|
let (mut generic_args, infer_args) = if let Some(generic_args) = segment.args.as_deref() {
|
|
match generic_args {
|
|
GenericArgs::AngleBracketed(data) => {
|
|
self.lower_angle_bracketed_parameter_data(data, param_mode, itctx)
|
|
}
|
|
GenericArgs::Parenthesized(data) => match generic_args_mode {
|
|
GenericArgsMode::ReturnTypeNotation => {
|
|
let err = match (&data.inputs[..], &data.output) {
|
|
([_, ..], FnRetTy::Default(_)) => {
|
|
BadReturnTypeNotation::Inputs { span: data.inputs_span }
|
|
}
|
|
([], FnRetTy::Default(_)) => {
|
|
BadReturnTypeNotation::NeedsDots { span: data.inputs_span }
|
|
}
|
|
// The case `T: Trait<method(..) -> Ret>` is handled in the parser.
|
|
(_, FnRetTy::Ty(ty)) => {
|
|
let span = data.inputs_span.shrink_to_hi().to(ty.span);
|
|
BadReturnTypeNotation::Output {
|
|
span,
|
|
suggestion: RTNSuggestion {
|
|
output: span,
|
|
input: data.inputs_span,
|
|
},
|
|
}
|
|
}
|
|
};
|
|
let mut err = self.dcx().create_err(err);
|
|
if !self.tcx.features().return_type_notation()
|
|
&& self.tcx.sess.is_nightly_build()
|
|
{
|
|
add_feature_diagnostics(
|
|
&mut err,
|
|
&self.tcx.sess,
|
|
sym::return_type_notation,
|
|
);
|
|
}
|
|
err.emit();
|
|
(
|
|
GenericArgsCtor {
|
|
args: Default::default(),
|
|
constraints: &[],
|
|
parenthesized: hir::GenericArgsParentheses::ReturnTypeNotation,
|
|
span: path_span,
|
|
},
|
|
false,
|
|
)
|
|
}
|
|
GenericArgsMode::ParenSugar | GenericArgsMode::Silence => self
|
|
.lower_parenthesized_parameter_data(
|
|
data,
|
|
itctx,
|
|
bound_modifier_allowed_features,
|
|
),
|
|
GenericArgsMode::Err => {
|
|
// Suggest replacing parentheses with angle brackets `Trait(params...)` to `Trait<params...>`
|
|
let sub = if !data.inputs.is_empty() {
|
|
// Start of the span to the 1st character of 1st argument
|
|
let open_param = data.inputs_span.shrink_to_lo().to(data
|
|
.inputs
|
|
.first()
|
|
.unwrap()
|
|
.span
|
|
.shrink_to_lo());
|
|
// Last character position of last argument to the end of the span
|
|
let close_param = data
|
|
.inputs
|
|
.last()
|
|
.unwrap()
|
|
.span
|
|
.shrink_to_hi()
|
|
.to(data.inputs_span.shrink_to_hi());
|
|
|
|
Some(UseAngleBrackets { open_param, close_param })
|
|
} else {
|
|
None
|
|
};
|
|
self.dcx().emit_err(GenericTypeWithParentheses { span: data.span, sub });
|
|
(
|
|
self.lower_angle_bracketed_parameter_data(
|
|
&data.as_angle_bracketed_args(),
|
|
param_mode,
|
|
itctx,
|
|
)
|
|
.0,
|
|
false,
|
|
)
|
|
}
|
|
},
|
|
GenericArgs::ParenthesizedElided(span) => {
|
|
match generic_args_mode {
|
|
GenericArgsMode::ReturnTypeNotation | GenericArgsMode::Silence => {
|
|
// Ok
|
|
}
|
|
GenericArgsMode::ParenSugar | GenericArgsMode::Err => {
|
|
self.dcx().emit_err(BadReturnTypeNotation::Position { span: *span });
|
|
}
|
|
}
|
|
(
|
|
GenericArgsCtor {
|
|
args: Default::default(),
|
|
constraints: &[],
|
|
parenthesized: hir::GenericArgsParentheses::ReturnTypeNotation,
|
|
span: *span,
|
|
},
|
|
false,
|
|
)
|
|
}
|
|
}
|
|
} else {
|
|
(
|
|
GenericArgsCtor {
|
|
args: Default::default(),
|
|
constraints: &[],
|
|
parenthesized: hir::GenericArgsParentheses::No,
|
|
span: path_span.shrink_to_hi(),
|
|
},
|
|
param_mode == ParamMode::Optional,
|
|
)
|
|
};
|
|
|
|
let has_lifetimes =
|
|
generic_args.args.iter().any(|arg| matches!(arg, GenericArg::Lifetime(_)));
|
|
|
|
// FIXME(return_type_notation): Is this correct? I think so.
|
|
if generic_args.parenthesized != hir::GenericArgsParentheses::ParenSugar && !has_lifetimes {
|
|
self.maybe_insert_elided_lifetimes_in_path(
|
|
path_span,
|
|
segment.id,
|
|
segment.ident.span,
|
|
&mut generic_args,
|
|
);
|
|
}
|
|
|
|
let res = self.expect_full_res(segment.id);
|
|
let hir_id = self.lower_node_id(segment.id);
|
|
debug!(
|
|
"lower_path_segment: ident={:?} original-id={:?} new-id={:?}",
|
|
segment.ident, segment.id, hir_id,
|
|
);
|
|
|
|
hir::PathSegment {
|
|
ident: self.lower_ident(segment.ident),
|
|
hir_id,
|
|
res: self.lower_res(res),
|
|
infer_args,
|
|
args: if generic_args.is_empty() && generic_args.span.is_empty() {
|
|
None
|
|
} else {
|
|
Some(generic_args.into_generic_args(self))
|
|
},
|
|
}
|
|
}
|
|
|
|
fn maybe_insert_elided_lifetimes_in_path(
|
|
&mut self,
|
|
path_span: Span,
|
|
segment_id: NodeId,
|
|
segment_ident_span: Span,
|
|
generic_args: &mut GenericArgsCtor<'hir>,
|
|
) {
|
|
let (start, end) = match self.resolver.get_lifetime_res(segment_id) {
|
|
Some(LifetimeRes::ElidedAnchor { start, end }) => (start, end),
|
|
None => return,
|
|
Some(res) => {
|
|
span_bug!(path_span, "expected an elided lifetime to insert. found {res:?}")
|
|
}
|
|
};
|
|
let expected_lifetimes = end.as_usize() - start.as_usize();
|
|
debug!(expected_lifetimes);
|
|
|
|
// Note: these spans are used for diagnostics when they can't be inferred.
|
|
// See rustc_resolve::late::lifetimes::LifetimeContext::add_missing_lifetime_specifiers_label
|
|
let elided_lifetime_span = if generic_args.span.is_empty() {
|
|
// If there are no brackets, use the identifier span.
|
|
// HACK: we use find_ancestor_inside to properly suggest elided spans in paths
|
|
// originating from macros, since the segment's span might be from a macro arg.
|
|
segment_ident_span.find_ancestor_inside(path_span).unwrap_or(path_span)
|
|
} else if generic_args.is_empty() {
|
|
// If there are brackets, but not generic arguments, then use the opening bracket
|
|
generic_args.span.with_hi(generic_args.span.lo() + BytePos(1))
|
|
} else {
|
|
// Else use an empty span right after the opening bracket.
|
|
generic_args.span.with_lo(generic_args.span.lo() + BytePos(1)).shrink_to_lo()
|
|
};
|
|
|
|
generic_args.args.insert_many(
|
|
0,
|
|
(start.as_u32()..end.as_u32()).map(|i| {
|
|
let id = NodeId::from_u32(i);
|
|
let l = self.lower_lifetime_anon_in_path(id, elided_lifetime_span);
|
|
GenericArg::Lifetime(l)
|
|
}),
|
|
);
|
|
}
|
|
|
|
pub(crate) fn lower_angle_bracketed_parameter_data(
|
|
&mut self,
|
|
data: &AngleBracketedArgs,
|
|
param_mode: ParamMode,
|
|
itctx: ImplTraitContext,
|
|
) -> (GenericArgsCtor<'hir>, bool) {
|
|
let has_non_lt_args = data.args.iter().any(|arg| match arg {
|
|
AngleBracketedArg::Arg(ast::GenericArg::Lifetime(_))
|
|
| AngleBracketedArg::Constraint(_) => false,
|
|
AngleBracketedArg::Arg(ast::GenericArg::Type(_) | ast::GenericArg::Const(_)) => true,
|
|
});
|
|
let args = data
|
|
.args
|
|
.iter()
|
|
.filter_map(|arg| match arg {
|
|
AngleBracketedArg::Arg(arg) => Some(self.lower_generic_arg(arg, itctx)),
|
|
AngleBracketedArg::Constraint(_) => None,
|
|
})
|
|
.collect();
|
|
let constraints =
|
|
self.arena.alloc_from_iter(data.args.iter().filter_map(|arg| match arg {
|
|
AngleBracketedArg::Constraint(c) => {
|
|
Some(self.lower_assoc_item_constraint(c, itctx))
|
|
}
|
|
AngleBracketedArg::Arg(_) => None,
|
|
}));
|
|
let ctor = GenericArgsCtor {
|
|
args,
|
|
constraints,
|
|
parenthesized: hir::GenericArgsParentheses::No,
|
|
span: data.span,
|
|
};
|
|
(ctor, !has_non_lt_args && param_mode == ParamMode::Optional)
|
|
}
|
|
|
|
fn lower_parenthesized_parameter_data(
|
|
&mut self,
|
|
data: &ParenthesizedArgs,
|
|
itctx: ImplTraitContext,
|
|
bound_modifier_allowed_features: Option<Arc<[Symbol]>>,
|
|
) -> (GenericArgsCtor<'hir>, bool) {
|
|
// Switch to `PassThrough` mode for anonymous lifetimes; this
|
|
// means that we permit things like `&Ref<T>`, where `Ref` has
|
|
// a hidden lifetime parameter. This is needed for backwards
|
|
// compatibility, even in contexts like an impl header where
|
|
// we generally don't permit such things (see #51008).
|
|
let ParenthesizedArgs { span, inputs, inputs_span, output } = data;
|
|
let inputs = self.arena.alloc_from_iter(inputs.iter().map(|ty| {
|
|
self.lower_ty_direct(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitParam))
|
|
}));
|
|
let output_ty = match output {
|
|
// Only allow `impl Trait` in return position. i.e.:
|
|
// ```rust
|
|
// fn f(_: impl Fn() -> impl Debug) -> impl Fn() -> impl Debug
|
|
// // disallowed --^^^^^^^^^^ allowed --^^^^^^^^^^
|
|
// ```
|
|
FnRetTy::Ty(ty) if matches!(itctx, ImplTraitContext::OpaqueTy { .. }) => {
|
|
if self.tcx.features().impl_trait_in_fn_trait_return() {
|
|
self.lower_ty(ty, itctx)
|
|
} else {
|
|
self.lower_ty(
|
|
ty,
|
|
ImplTraitContext::FeatureGated(
|
|
ImplTraitPosition::FnTraitReturn,
|
|
sym::impl_trait_in_fn_trait_return,
|
|
),
|
|
)
|
|
}
|
|
}
|
|
FnRetTy::Ty(ty) => {
|
|
self.lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::FnTraitReturn))
|
|
}
|
|
FnRetTy::Default(_) => self.arena.alloc(self.ty_tup(*span, &[])),
|
|
};
|
|
let args = smallvec![GenericArg::Type(
|
|
self.arena.alloc(self.ty_tup(*inputs_span, inputs)).try_as_ambig_ty().unwrap()
|
|
)];
|
|
|
|
// If we have a bound like `async Fn() -> T`, make sure that we mark the
|
|
// `Output = T` associated type bound with the right feature gates.
|
|
let mut output_span = output_ty.span;
|
|
if let Some(bound_modifier_allowed_features) = bound_modifier_allowed_features {
|
|
output_span = self.mark_span_with_reason(
|
|
DesugaringKind::BoundModifier,
|
|
output_span,
|
|
Some(bound_modifier_allowed_features),
|
|
);
|
|
}
|
|
let constraint = self.assoc_ty_binding(sym::Output, output_span, output_ty);
|
|
|
|
(
|
|
GenericArgsCtor {
|
|
args,
|
|
constraints: arena_vec![self; constraint],
|
|
parenthesized: hir::GenericArgsParentheses::ParenSugar,
|
|
span: data.inputs_span,
|
|
},
|
|
false,
|
|
)
|
|
}
|
|
|
|
/// An associated type binding (i.e., associated type equality constraint).
|
|
pub(crate) fn assoc_ty_binding(
|
|
&mut self,
|
|
assoc_ty_name: rustc_span::Symbol,
|
|
span: Span,
|
|
ty: &'hir hir::Ty<'hir>,
|
|
) -> hir::AssocItemConstraint<'hir> {
|
|
let ident = Ident::with_dummy_span(assoc_ty_name);
|
|
let kind = hir::AssocItemConstraintKind::Equality { term: ty.into() };
|
|
let args = arena_vec![self;];
|
|
let constraints = arena_vec![self;];
|
|
let gen_args = self.arena.alloc(hir::GenericArgs {
|
|
args,
|
|
constraints,
|
|
parenthesized: hir::GenericArgsParentheses::No,
|
|
span_ext: DUMMY_SP,
|
|
});
|
|
hir::AssocItemConstraint {
|
|
hir_id: self.next_id(),
|
|
gen_args,
|
|
span: self.lower_span(span),
|
|
ident,
|
|
kind,
|
|
}
|
|
}
|
|
|
|
/// When a bound is annotated with `async`, it signals to lowering that the trait
|
|
/// that the bound refers to should be mapped to the "async" flavor of the trait.
|
|
///
|
|
/// This only needs to be done until we unify `AsyncFn` and `Fn` traits into one
|
|
/// that is generic over `async`ness, if that's ever possible, or modify the
|
|
/// lowering of `async Fn()` bounds to desugar to another trait like `LendingFn`.
|
|
fn map_trait_to_async_trait(&self, def_id: DefId) -> Option<DefId> {
|
|
let lang_items = self.tcx.lang_items();
|
|
if Some(def_id) == lang_items.fn_trait() {
|
|
lang_items.async_fn_trait()
|
|
} else if Some(def_id) == lang_items.fn_mut_trait() {
|
|
lang_items.async_fn_mut_trait()
|
|
} else if Some(def_id) == lang_items.fn_once_trait() {
|
|
lang_items.async_fn_once_trait()
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
}
|