use super::{ImplTraitContext, ImplTraitPosition};
use crate::Arena;
-use rustc_ast::node_id::NodeMap;
use rustc_ast::ptr::P;
use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
use rustc_ast::*;
self.lctx.with_parent_item_lifetime_defs(hir_id, |this| {
let this = &mut ItemLowerer { lctx: this };
match item.kind {
- ItemKind::Mod(..) => {
- let def_id = this.lctx.lower_node_id(item.id).expect_owner();
- let old_current_module = mem::replace(&mut this.lctx.current_module, def_id);
- visit::walk_item(this, item);
- this.lctx.current_module = old_current_module;
- }
ItemKind::Impl(box ImplKind { ref of_trait, .. }) => {
this.with_trait_impl_ref(of_trait, |this| visit::walk_item(this, item));
}
);
let sig = hir::FnSig {
decl,
- header: this.lower_fn_header(header, fn_sig_span, id),
+ header: this.lower_fn_header(header),
span: this.lower_span(fn_sig_span),
};
hir::ItemKind::Fn(sig, generics, body_id)
}
ModKind::Unloaded => panic!("`mod` items should have been loaded by now"),
},
- ItemKind::ForeignMod(ref fm) => {
- if fm.abi.is_none() {
- self.maybe_lint_missing_abi(span, id, abi::Abi::C { unwind: false });
- }
- hir::ItemKind::ForeignMod {
- abi: fm.abi.map_or(abi::Abi::C { unwind: false }, |abi| self.lower_abi(abi)),
- items: self
- .arena
- .alloc_from_iter(fm.items.iter().map(|x| self.lower_foreign_item_ref(x))),
- }
- }
+ ItemKind::ForeignMod(ref fm) => hir::ItemKind::ForeignMod {
+ abi: fm.abi.map_or(abi::Abi::FALLBACK, |abi| self.lower_abi(abi)),
+ items: self
+ .arena
+ .alloc_from_iter(fm.items.iter().map(|x| self.lower_foreign_item_ref(x))),
+ },
ItemKind::GlobalAsm(ref asm) => {
hir::ItemKind::GlobalAsm(self.lower_inline_asm(span, asm))
}
this.lower_trait_ref(trait_ref, ImplTraitContext::disallowed())
});
- if let Some(ref trait_ref) = trait_ref {
- if let Res::Def(DefKind::Trait, def_id) = trait_ref.path.res {
- this.trait_impls
- .entry(def_id)
- .or_default()
- .push(lowered_trait_def_id);
- }
- }
-
let lowered_ty = this.lower_ty(ty, ImplTraitContext::disallowed());
(trait_ref, lowered_ty)
AssocItemKind::Fn(box FnKind(_, ref sig, ref generics, None)) => {
let names = self.lower_fn_params_to_names(&sig.decl);
let (generics, sig) =
- self.lower_method_sig(generics, sig, trait_item_def_id, false, None, i.id);
+ self.lower_method_sig(generics, sig, trait_item_def_id, false, None);
(generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Required(names)))
}
AssocItemKind::Fn(box FnKind(_, ref sig, ref generics, Some(ref body))) => {
trait_item_def_id,
false,
asyncness.opt_return_id(),
- i.id,
);
(generics, hir::TraitItemKind::Fn(sig, hir::TraitFn::Provided(body_id)))
}
impl_item_def_id,
impl_trait_return_allow,
asyncness.opt_return_id(),
- i.id,
);
(generics, hir::ImplItemKind::Fn(sig, body_id))
fn_def_id: LocalDefId,
impl_trait_return_allow: bool,
is_async: Option<NodeId>,
- id: NodeId,
) -> (hir::Generics<'hir>, hir::FnSig<'hir>) {
- let header = self.lower_fn_header(sig.header, sig.span, id);
+ let header = self.lower_fn_header(sig.header);
let (generics, decl) = self.add_in_band_defs(
generics,
fn_def_id,
(generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })
}
- fn lower_fn_header(&mut self, h: FnHeader, span: Span, id: NodeId) -> hir::FnHeader {
+ fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader {
hir::FnHeader {
unsafety: self.lower_unsafety(h.unsafety),
asyncness: self.lower_asyncness(h.asyncness),
constness: self.lower_constness(h.constness),
- abi: self.lower_extern(h.ext, span, id),
+ abi: self.lower_extern(h.ext),
}
}
})
}
- pub(super) fn lower_extern(&mut self, ext: Extern, span: Span, id: NodeId) -> abi::Abi {
+ pub(super) fn lower_extern(&mut self, ext: Extern) -> abi::Abi {
match ext {
Extern::None => abi::Abi::Rust,
- Extern::Implicit => {
- self.maybe_lint_missing_abi(span, id, abi::Abi::C { unwind: false });
- abi::Abi::C { unwind: false }
- }
+ Extern::Implicit => abi::Abi::FALLBACK,
Extern::Explicit(abi) => self.lower_abi(abi),
}
}
generics: &Generics,
itctx: ImplTraitContext<'_, 'hir>,
) -> GenericsCtor<'hir> {
- // Collect `?Trait` bounds in where clause and move them to parameter definitions.
- let mut add_bounds: NodeMap<Vec<_>> = Default::default();
+ // Error if `?Trait` bounds in where clauses don't refer directly to type paramters.
+ // Note: we used to clone these bounds directly onto the type parameter (and avoid lowering
+ // these into hir when we lower thee where clauses), but this makes it quite difficult to
+ // keep track of the Span info. Now, `add_implicitly_sized` in `AstConv` checks both param bounds and
+ // where clauses for `?Sized`.
for pred in &generics.where_clause.predicates {
if let WherePredicate::BoundPredicate(ref bound_pred) = *pred {
'next_bound: for bound in &bound_pred.bounds {
{
for param in &generics.params {
if def_id == self.resolver.local_def_id(param.id).to_def_id() {
- add_bounds.entry(param.id).or_default().push(bound.clone());
continue 'next_bound;
}
}
}
GenericsCtor {
- params: self.lower_generic_params_mut(&generics.params, &add_bounds, itctx).collect(),
+ params: self.lower_generic_params_mut(&generics.params, itctx).collect(),
where_clause: self.lower_where_clause(&generics.where_clause),
span: self.lower_span(generics.span),
}
ref bounded_ty,
ref bounds,
span,
- }) => {
- self.with_in_scope_lifetime_defs(&bound_generic_params, |this| {
- hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
- bound_generic_params: this.lower_generic_params(
- bound_generic_params,
- &NodeMap::default(),
- ImplTraitContext::disallowed(),
- ),
- bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
- bounds: this.arena.alloc_from_iter(bounds.iter().map(
- |bound| match bound {
- // We used to ignore `?Trait` bounds, as they were copied into type
- // parameters already, but we need to keep them around only for
- // diagnostics when we suggest removal of `?Sized` bounds. See
- // `suggest_constraining_type_param`. This will need to change if
- // we ever allow something *other* than `?Sized`.
- GenericBound::Trait(p, TraitBoundModifier::Maybe) => {
- hir::GenericBound::Unsized(this.lower_span(p.span))
- }
- _ => this.lower_param_bound(bound, ImplTraitContext::disallowed()),
- },
- )),
- span: this.lower_span(span),
- })
+ }) => self.with_in_scope_lifetime_defs(&bound_generic_params, |this| {
+ hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
+ bound_generic_params: this
+ .lower_generic_params(bound_generic_params, ImplTraitContext::disallowed()),
+ bounded_ty: this.lower_ty(bounded_ty, ImplTraitContext::disallowed()),
+ bounds: this.arena.alloc_from_iter(bounds.iter().map(|bound| {
+ this.lower_param_bound(bound, ImplTraitContext::disallowed())
+ })),
+ span: this.lower_span(span),
})
- }
+ }),
WherePredicate::RegionPredicate(WhereRegionPredicate {
ref lifetime,
ref bounds,
projects / rust.git / blobdiff