bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Syntax for hir::Ty.

Browse source
This commit is contained in:
Camille GILLOT 2019-11-30 17:46:46 +01:00
parent 66f9198047
commit 6b87d5cdf1
25 changed files with 429 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/librustc/arena.rs
View file

@ -132,21 +132,21 @@ macro_rules! arena_types {
[] expr: rustc::hir::Expr<$tcx>,
[] field: rustc::hir::Field<$tcx>,
[] field_pat: rustc::hir::FieldPat<$tcx>,
[] fn_decl: rustc::hir::FnDecl,
[] fn_decl: rustc::hir::FnDecl<$tcx>,
[] foreign_item: rustc::hir::ForeignItem<$tcx>,
[] impl_item_ref: rustc::hir::ImplItemRef,
[] impl_item_ref: rustc::hir::ImplItemRef<$tcx>,
[] inline_asm: rustc::hir::InlineAsm<$tcx>,
[] local: rustc::hir::Local<$tcx>,
[few] macro_def: rustc::hir::MacroDef<$tcx>,
[] param: rustc::hir::Param<$tcx>,
[] pat: rustc::hir::Pat<$tcx>,
[] path: rustc::hir::Path,
[] path_segment: rustc::hir::PathSegment,
[] qpath: rustc::hir::QPath,
[] path: rustc::hir::Path<$tcx>,
[] path_segment: rustc::hir::PathSegment<$tcx>,
[] qpath: rustc::hir::QPath<$tcx>,
[] stmt: rustc::hir::Stmt<$tcx>,
[] struct_field: rustc::hir::StructField<$tcx>,
[] trait_item_ref: rustc::hir::TraitItemRef,
[] ty: rustc::hir::Ty,
[] ty: rustc::hir::Ty<$tcx>,
[] variant: rustc::hir::Variant<$tcx>,
], $tcx);
)

97
src/librustc/hir/intravisit.rs
View file

@ -42,10 +42,10 @@ use syntax_pos::Span;
#[derive(Copy, Clone)]
pub enum FnKind<'a> {
/// `#[xxx] pub async/const/extern "Abi" fn foo()`
ItemFn(Ident, &'a Generics, FnHeader, &'a Visibility, &'a [Attribute]),
ItemFn(Ident, &'a Generics<'a>, FnHeader, &'a Visibility<'a>, &'a [Attribute]),
/// `fn foo(&self)`
Method(Ident, &'a FnSig<'a>, Option<&'a Visibility>, &'a [Attribute]),
Method(Ident, &'a FnSig<'a>, Option<&'a Visibility<'a>>, &'a [Attribute]),
/// `|x, y| {}`
Closure(&'a [Attribute]),
@ -274,25 +274,25 @@ pub trait Visitor<'v>: Sized {
fn visit_expr(&mut self, ex: &'v Expr<'v>) {
walk_expr(self, ex)
}
fn visit_ty(&mut self, t: &'v Ty) {
fn visit_ty(&mut self, t: &'v Ty<'v>) {
walk_ty(self, t)
}
fn visit_generic_param(&mut self, p: &'v GenericParam) {
fn visit_generic_param(&mut self, p: &'v GenericParam<'v>) {
walk_generic_param(self, p)
}
fn visit_generics(&mut self, g: &'v Generics) {
fn visit_generics(&mut self, g: &'v Generics<'v>) {
walk_generics(self, g)
}
fn visit_where_predicate(&mut self, predicate: &'v WherePredicate) {
fn visit_where_predicate(&mut self, predicate: &'v WherePredicate<'v>) {
walk_where_predicate(self, predicate)
}
fn visit_fn_decl(&mut self, fd: &'v FnDecl) {
fn visit_fn_decl(&mut self, fd: &'v FnDecl<'v>) {
walk_fn_decl(self, fd)
}
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: BodyId, s: Span, id: HirId) {
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl<'v>, b: BodyId, s: Span, id: HirId) {
walk_fn(self, fk, fd, b, s, id)
}
fn visit_use(&mut self, path: &'v Path, hir_id: HirId) {
fn visit_use(&mut self, path: &'v Path<'v>, hir_id: HirId) {
walk_use(self, path, hir_id)
}
fn visit_trait_item(&mut self, ti: &'v TraitItem<'v>) {
@ -304,23 +304,23 @@ pub trait Visitor<'v>: Sized {
fn visit_impl_item(&mut self, ii: &'v ImplItem<'v>) {
walk_impl_item(self, ii)
}
fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef) {
fn visit_impl_item_ref(&mut self, ii: &'v ImplItemRef<'v>) {
walk_impl_item_ref(self, ii)
}
fn visit_trait_ref(&mut self, t: &'v TraitRef) {
fn visit_trait_ref(&mut self, t: &'v TraitRef<'v>) {
walk_trait_ref(self, t)
}
fn visit_param_bound(&mut self, bounds: &'v GenericBound) {
fn visit_param_bound(&mut self, bounds: &'v GenericBound<'v>) {
walk_param_bound(self, bounds)
}
fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: TraitBoundModifier) {
fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef<'v>, m: TraitBoundModifier) {
walk_poly_trait_ref(self, t, m)
}
fn visit_variant_data(
&mut self,
s: &'v VariantData<'v>,
_: Name,
_: &'v Generics,
_: &'v Generics<'v>,
_parent_id: HirId,
_: Span,
) {
@ -332,19 +332,19 @@ pub trait Visitor<'v>: Sized {
fn visit_enum_def(
&mut self,
enum_definition: &'v EnumDef<'v>,
generics: &'v Generics,
generics: &'v Generics<'v>,
item_id: HirId,
_: Span,
) {
walk_enum_def(self, enum_definition, generics, item_id)
}
fn visit_variant(&mut self, v: &'v Variant<'v>, g: &'v Generics, item_id: HirId) {
fn visit_variant(&mut self, v: &'v Variant<'v>, g: &'v Generics<'v>, item_id: HirId) {
walk_variant(self, v, g, item_id)
}
fn visit_label(&mut self, label: &'v Label) {
walk_label(self, label)
}
fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg) {
fn visit_generic_arg(&mut self, generic_arg: &'v GenericArg<'v>) {
match generic_arg {
GenericArg::Lifetime(lt) => self.visit_lifetime(lt),
GenericArg::Type(ty) => self.visit_ty(ty),
@ -354,26 +354,26 @@ pub trait Visitor<'v>: Sized {
fn visit_lifetime(&mut self, lifetime: &'v Lifetime) {
walk_lifetime(self, lifetime)
}
fn visit_qpath(&mut self, qpath: &'v QPath, id: HirId, span: Span) {
fn visit_qpath(&mut self, qpath: &'v QPath<'v>, id: HirId, span: Span) {
walk_qpath(self, qpath, id, span)
}
fn visit_path(&mut self, path: &'v Path, _id: HirId) {
fn visit_path(&mut self, path: &'v Path<'v>, _id: HirId) {
walk_path(self, path)
}
fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment) {
fn visit_path_segment(&mut self, path_span: Span, path_segment: &'v PathSegment<'v>) {
walk_path_segment(self, path_span, path_segment)
}
fn visit_generic_args(&mut self, path_span: Span, generic_args: &'v GenericArgs) {
fn visit_generic_args(&mut self, path_span: Span, generic_args: &'v GenericArgs<'v>) {
walk_generic_args(self, path_span, generic_args)
}
fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding) {
fn visit_assoc_type_binding(&mut self, type_binding: &'v TypeBinding<'v>) {
walk_assoc_type_binding(self, type_binding)
}
fn visit_attribute(&mut self, _attr: &'v Attribute) {}
fn visit_macro_def(&mut self, macro_def: &'v MacroDef<'v>) {
walk_macro_def(self, macro_def)
}
fn visit_vis(&mut self, vis: &'v Visibility) {
fn visit_vis(&mut self, vis: &'v Visibility<'v>) {
walk_vis(self, vis)
}
fn visit_associated_item_kind(&mut self, kind: &'v AssocItemKind) {
@ -445,7 +445,7 @@ pub fn walk_lifetime<'v, V: Visitor<'v>>(visitor: &mut V, lifetime: &'v Lifetime
pub fn walk_poly_trait_ref<'v, V>(
visitor: &mut V,
trait_ref: &'v PolyTraitRef,
trait_ref: &'v PolyTraitRef<'v>,
_modifier: TraitBoundModifier,
) where
V: Visitor<'v>,
@ -454,7 +454,7 @@ pub fn walk_poly_trait_ref<'v, V>(
visitor.visit_trait_ref(&trait_ref.trait_ref);
}
pub fn walk_trait_ref<'v, V>(visitor: &mut V, trait_ref: &'v TraitRef)
pub fn walk_trait_ref<'v, V>(visitor: &mut V, trait_ref: &'v TraitRef<'v>)
where
V: Visitor<'v>,
{
@ -553,7 +553,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
walk_list!(visitor, visit_attribute, item.attrs);
}
pub fn walk_use<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path, hir_id: HirId) {
pub fn walk_use<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>, hir_id: HirId) {
visitor.visit_id(hir_id);
visitor.visit_path(path, hir_id);
}
@ -561,7 +561,7 @@ pub fn walk_use<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path, hir_id: Hir
pub fn walk_enum_def<'v, V: Visitor<'v>>(
visitor: &mut V,
enum_definition: &'v EnumDef<'v>,
generics: &'v Generics,
generics: &'v Generics<'v>,
item_id: HirId,
) {
visitor.visit_id(item_id);
@ -571,7 +571,7 @@ pub fn walk_enum_def<'v, V: Visitor<'v>>(
pub fn walk_variant<'v, V: Visitor<'v>>(
visitor: &mut V,
variant: &'v Variant<'v>,
generics: &'v Generics,
generics: &'v Generics<'v>,
parent_item_id: HirId,
) {
visitor.visit_ident(variant.ident);
@ -587,7 +587,7 @@ pub fn walk_variant<'v, V: Visitor<'v>>(
walk_list!(visitor, visit_attribute, variant.attrs);
}
pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {
visitor.visit_id(typ.hir_id);
match typ.kind {
@ -627,7 +627,12 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
}
}
pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: HirId, span: Span) {
pub fn walk_qpath<'v, V: Visitor<'v>>(
visitor: &mut V,
qpath: &'v QPath<'v>,
id: HirId,
span: Span,
) {
match *qpath {
QPath::Resolved(ref maybe_qself, ref path) => {
if let Some(ref qself) = *maybe_qself {
@ -642,7 +647,7 @@ pub fn walk_qpath<'v, V: Visitor<'v>>(visitor: &mut V, qpath: &'v QPath, id: Hir
}
}
pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path<'v>) {
for segment in &path.segments {
visitor.visit_path_segment(path.span, segment);
}
@ -651,7 +656,7 @@ pub fn walk_path<'v, V: Visitor<'v>>(visitor: &mut V, path: &'v Path) {
pub fn walk_path_segment<'v, V: Visitor<'v>>(
visitor: &mut V,
path_span: Span,
segment: &'v PathSegment,
segment: &'v PathSegment<'v>,
) {
visitor.visit_ident(segment.ident);
if let Some(id) = segment.hir_id {
@ -665,13 +670,16 @@ pub fn walk_path_segment<'v, V: Visitor<'v>>(
pub fn walk_generic_args<'v, V: Visitor<'v>>(
visitor: &mut V,
_path_span: Span,
generic_args: &'v GenericArgs,
generic_args: &'v GenericArgs<'v>,
) {
walk_list!(visitor, visit_generic_arg, &generic_args.args);
walk_list!(visitor, visit_assoc_type_binding, &generic_args.bindings);
}
pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(visitor: &mut V, type_binding: &'v TypeBinding) {
pub fn walk_assoc_type_binding<'v, V: Visitor<'v>>(
visitor: &mut V,
type_binding: &'v TypeBinding<'v>,
) {
visitor.visit_id(type_binding.hir_id);
visitor.visit_ident(type_binding.ident);
match type_binding.kind {
@ -747,7 +755,7 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v
walk_list!(visitor, visit_attribute, foreign_item.attrs);
}
pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericBound) {
pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericBound<'v>) {
match *bound {
GenericBound::Trait(ref typ, modifier) => {
visitor.visit_poly_trait_ref(typ, modifier);
@ -756,7 +764,7 @@ pub fn walk_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v GenericB
}
}
pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam) {
pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v GenericParam<'v>) {
visitor.visit_id(param.hir_id);
walk_list!(visitor, visit_attribute, &param.attrs);
match param.name {
@ -771,12 +779,15 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
walk_list!(visitor, visit_param_bound, &param.bounds);
}
pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics) {
pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics<'v>) {
walk_list!(visitor, visit_generic_param, &generics.params);
walk_list!(visitor, visit_where_predicate, &generics.where_clause.predicates);
}
pub fn walk_where_predicate<'v, V: Visitor<'v>>(visitor: &mut V, predicate: &'v WherePredicate) {
pub fn walk_where_predicate<'v, V: Visitor<'v>>(
visitor: &mut V,
predicate: &'v WherePredicate<'v>,
) {
match predicate {
&WherePredicate::BoundPredicate(WhereBoundPredicate {
ref bounded_ty,
@ -804,13 +815,13 @@ pub fn walk_where_predicate<'v, V: Visitor<'v>>(visitor: &mut V, predicate: &'v
}
}
pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FunctionRetTy) {
pub fn walk_fn_ret_ty<'v, V: Visitor<'v>>(visitor: &mut V, ret_ty: &'v FunctionRetTy<'v>) {
if let Return(ref output_ty) = *ret_ty {
visitor.visit_ty(output_ty)
}
}
pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl) {
pub fn walk_fn_decl<'v, V: Visitor<'v>>(visitor: &mut V, function_declaration: &'v FnDecl<'v>) {
for ty in &function_declaration.inputs {
visitor.visit_ty(ty)
}
@ -829,7 +840,7 @@ pub fn walk_fn_kind<'v, V: Visitor<'v>>(visitor: &mut V, function_kind: FnKind<'
pub fn walk_fn<'v, V: Visitor<'v>>(
visitor: &mut V,
function_kind: FnKind<'v>,
function_declaration: &'v FnDecl,
function_declaration: &'v FnDecl<'v>,
body_id: BodyId,
_span: Span,
id: HirId,
@ -927,7 +938,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt
}
}
pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, impl_item_ref: &'v ImplItemRef) {
pub fn walk_impl_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, impl_item_ref: &'v ImplItemRef<'v>) {
// N.B., deliberately force a compilation error if/when new fields are added.
let ImplItemRef { id, ident, ref kind, span: _, ref vis, ref defaultness } = *impl_item_ref;
visitor.visit_nested_impl_item(id);
@ -1099,7 +1110,7 @@ pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm<'v>) {
walk_list!(visitor, visit_attribute, arm.attrs);
}
pub fn walk_vis<'v, V: Visitor<'v>>(visitor: &mut V, vis: &'v Visibility) {
pub fn walk_vis<'v, V: Visitor<'v>>(visitor: &mut V, vis: &'v Visibility<'v>) {
if let VisibilityKind::Restricted { ref path, hir_id } = vis.node {
visitor.visit_id(hir_id);
visitor.visit_path(path, hir_id)

97
src/librustc/hir/lowering.rs
View file

@ -212,7 +212,7 @@ enum ImplTraitContext<'a> {
/// equivalent to a fresh universal parameter like `fn foo<T: Debug>(x: T)`.
///
/// Newly generated parameters should be inserted into the given `Vec`.
Universal(&'a mut Vec<hir::GenericParam>),
Universal(&'a mut Vec<hir::GenericParam<'a>>),
/// Treat `impl Trait` as shorthand for a new opaque type.
/// Example: `fn foo() -> impl Debug`, where `impl Debug` is conceptually
@ -739,9 +739,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
parent_id: DefId,
anonymous_lifetime_mode: AnonymousLifetimeMode,
f: F,
) -> (Vec<hir::GenericParam>, T)
) -> (Vec<hir::GenericParam<'hir>>, T)
where
F: FnOnce(&mut LoweringContext<'_, '_>) -> (Vec<hir::GenericParam>, T),
F: FnOnce(&mut LoweringContext<'_, '_>) -> (Vec<hir::GenericParam<'hir>>, T),
{
assert!(!self.is_collecting_in_band_lifetimes);
assert!(self.lifetimes_to_define.is_empty());
@ -772,7 +772,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span: Span,
hir_name: ParamName,
parent_index: DefIndex,
) -> hir::GenericParam {
) -> hir::GenericParam<'hir> {
let node_id = self.resolver.next_node_id();
// Get the name we'll use to make the def-path. Note
@ -874,9 +874,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
parent_id: DefId,
anonymous_lifetime_mode: AnonymousLifetimeMode,
f: F,
) -> (hir::Generics, T)
) -> (hir::Generics<'hir>, T)
where
F: FnOnce(&mut LoweringContext<'_, '_>, &mut Vec<hir::GenericParam>) -> T,
F: FnOnce(&mut LoweringContext<'_, '_>, &mut Vec<hir::GenericParam<'hir>>) -> T,
{
let (in_band_defs, (mut lowered_generics, res)) =
self.with_in_scope_lifetime_defs(&generics.params, |this| {
@ -1026,7 +1026,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
constraint: &AssocTyConstraint,
itctx: ImplTraitContext<'_>,
) -> hir::TypeBinding {
) -> hir::TypeBinding<'hir> {
debug!("lower_assoc_ty_constraint(constraint={:?}, itctx={:?})", constraint, itctx);
let kind = match constraint.kind {
@ -1123,7 +1123,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
arg: &ast::GenericArg,
itctx: ImplTraitContext<'_>,
) -> hir::GenericArg {
) -> hir::GenericArg<'hir> {
match arg {
ast::GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.lower_lifetime(&lt)),
ast::GenericArg::Type(ty) => {
@ -1178,7 +1178,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext<'_>) -> P<hir::Ty> {
fn lower_ty(&mut self, t: &Ty, itctx: ImplTraitContext<'_>) -> P<hir::Ty<'hir>> {
P(self.lower_ty_direct(t, itctx))
}
@ -1189,7 +1189,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
path: &Path,
param_mode: ParamMode,
itctx: ImplTraitContext<'_>,
) -> hir::Ty {
) -> hir::Ty<'hir> {
let id = self.lower_node_id(t.id);
let qpath = self.lower_qpath(t.id, qself, path, param_mode, itctx);
let ty = self.ty_path(id, t.span, qpath);
@ -1199,15 +1199,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
ty
}
fn ty(&mut self, span: Span, kind: hir::TyKind) -> hir::Ty {
fn ty(&mut self, span: Span, kind: hir::TyKind<'hir>) -> hir::Ty<'hir> {
hir::Ty { hir_id: self.next_id(), kind, span }
}
fn ty_tup(&mut self, span: Span, tys: HirVec<hir::Ty>) -> hir::Ty {
fn ty_tup(&mut self, span: Span, tys: HirVec<hir::Ty<'hir>>) -> hir::Ty<'hir> {
self.ty(span, hir::TyKind::Tup(tys))
}
fn lower_ty_direct(&mut self, t: &Ty, mut itctx: ImplTraitContext<'_>) -> hir::Ty {
fn lower_ty_direct(&mut self, t: &Ty, mut itctx: ImplTraitContext<'_>) -> hir::Ty<'hir> {
let kind = match t.kind {
TyKind::Infer => hir::TyKind::Infer,
TyKind::Err => hir::TyKind::Err,
@ -1376,8 +1376,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span: Span,
fn_def_id: Option<DefId>,
opaque_ty_node_id: NodeId,
lower_bounds: impl FnOnce(&mut LoweringContext<'_, '_>) -> hir::GenericBounds,
) -> hir::TyKind {
lower_bounds: impl FnOnce(&mut LoweringContext<'_, '_>) -> hir::GenericBounds<'hir>,
) -> hir::TyKind<'hir> {
debug!(
"lower_opaque_impl_trait(fn_def_id={:?}, opaque_ty_node_id={:?}, span={:?})",
fn_def_id, opaque_ty_node_id, span,
@ -1433,7 +1433,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn generate_opaque_type(
&mut self,
opaque_ty_node_id: NodeId,
opaque_ty_item: hir::OpaqueTy,
opaque_ty_item: hir::OpaqueTy<'hir>,
span: Span,
opaque_ty_span: Span,
) -> hir::HirId {
@ -1461,8 +1461,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
opaque_ty_id: NodeId,
parent_index: DefIndex,
bounds: &hir::GenericBounds,
) -> (HirVec<hir::GenericArg>, HirVec<hir::GenericParam>) {
bounds: &hir::GenericBounds<'hir>,
) -> (HirVec<hir::GenericArg<'hir>>, HirVec<hir::GenericParam<'hir>>) {
debug!(
"lifetimes_from_impl_trait_bounds(opaque_ty_id={:?}, \
parent_index={:?}, \
@ -1480,8 +1480,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
collect_elided_lifetimes: bool,
currently_bound_lifetimes: Vec<hir::LifetimeName>,
already_defined_lifetimes: FxHashSet<hir::LifetimeName>,
output_lifetimes: Vec<hir::GenericArg>,
output_lifetime_params: Vec<hir::GenericParam>,
output_lifetimes: Vec<hir::GenericArg<'hir>>,
output_lifetime_params: Vec<hir::GenericParam<'hir>>,
}
impl<'r, 'a, 'v, 'hir> hir::intravisit::Visitor<'v> for ImplTraitLifetimeCollector<'r, 'a, 'hir> {
@ -1491,7 +1491,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::intravisit::NestedVisitorMap::None
}
fn visit_generic_args(&mut self, span: Span, parameters: &'v hir::GenericArgs) {
fn visit_generic_args(&mut self, span: Span, parameters: &'v hir::GenericArgs<'v>) {
// Don't collect elided lifetimes used inside of `Fn()` syntax.
if parameters.parenthesized {
let old_collect_elided_lifetimes = self.collect_elided_lifetimes;
@ -1503,7 +1503,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
fn visit_ty(&mut self, t: &'v hir::Ty) {
fn visit_ty(&mut self, t: &'v hir::Ty<'v>) {
// Don't collect elided lifetimes used inside of `fn()` syntax.
if let hir::TyKind::BareFn(_) = t.kind {
let old_collect_elided_lifetimes = self.collect_elided_lifetimes;
@ -1523,7 +1523,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn visit_poly_trait_ref(
&mut self,
trait_ref: &'v hir::PolyTraitRef,
trait_ref: &'v hir::PolyTraitRef<'v>,
modifier: hir::TraitBoundModifier,
) {
// Record the "stack height" of `for<'a>` lifetime bindings
@ -1533,7 +1533,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.currently_bound_lifetimes.truncate(old_len);
}
fn visit_generic_param(&mut self, param: &'v hir::GenericParam) {
fn visit_generic_param(&mut self, param: &'v hir::GenericParam<'v>) {
// Record the introduction of 'a in `for<'a> ...`.
if let hir::GenericParamKind::Lifetime { .. } = param.kind {
// Introduce lifetimes one at a time so that we can handle
@ -1639,7 +1639,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
p: &Path,
param_mode: ParamMode,
mut itctx: ImplTraitContext<'_>,
) -> hir::QPath {
) -> hir::QPath<'hir> {
let qself_position = qself.as_ref().map(|q| q.position);
let qself = qself.as_ref().map(|q| self.lower_ty(&q.ty, itctx.reborrow()));
@ -1799,7 +1799,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
p: &Path,
param_mode: ParamMode,
explicit_owner: Option<NodeId>,
) -> hir::Path {
) -> hir::Path<'hir> {
hir::Path {
res,
segments: p
@ -1821,7 +1821,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
fn lower_path(&mut self, id: NodeId, p: &Path, param_mode: ParamMode) -> hir::Path {
fn lower_path(&mut self, id: NodeId, p: &Path, param_mode: ParamMode) -> hir::Path<'hir> {
let res = self.expect_full_res(id);
let res = self.lower_res(res);
self.lower_path_extra(res, p, param_mode, None)
@ -1836,7 +1836,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
parenthesized_generic_args: ParenthesizedGenericArgs,
itctx: ImplTraitContext<'_>,
explicit_owner: Option<NodeId>,
) -> hir::PathSegment {
) -> hir::PathSegment<'hir> {
let (mut generic_args, infer_args) = if let Some(ref generic_args) = segment.args {
let msg = "parenthesized type parameters may only be used with a `Fn` trait";
match **generic_args {
@ -1981,7 +1981,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
data: &AngleBracketedArgs,
param_mode: ParamMode,
mut itctx: ImplTraitContext<'_>,
) -> (hir::GenericArgs, bool) {
) -> (hir::GenericArgs<'hir>, bool) {
let &AngleBracketedArgs { ref args, ref constraints, .. } = data;
let has_non_lt_args = args.iter().any(|arg| match arg {
ast::GenericArg::Lifetime(_) => false,
@ -2004,7 +2004,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_parenthesized_parameter_data(
&mut self,
data: &ParenthesizedArgs,
) -> (hir::GenericArgs, bool) {
) -> (hir::GenericArgs<'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
@ -2098,10 +2098,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
fn lower_fn_decl(
&mut self,
decl: &FnDecl,
mut in_band_ty_params: Option<(DefId, &mut Vec<hir::GenericParam>)>,
mut in_band_ty_params: Option<(DefId, &mut Vec<hir::GenericParam<'hir>>)>,
impl_trait_return_allow: bool,
make_ret_async: Option<NodeId>,
) -> P<hir::FnDecl> {
) -> P<hir::FnDecl<'hir>> {
debug!(
"lower_fn_decl(\
fn_decl: {:?}, \
@ -2207,7 +2207,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
output: &FunctionRetTy,
fn_def_id: DefId,
opaque_ty_node_id: NodeId,
) -> hir::FunctionRetTy {
) -> hir::FunctionRetTy<'hir> {
debug!(
"lower_async_fn_ret_ty(\
output={:?}, \
@ -2384,7 +2384,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
output: &FunctionRetTy,
fn_def_id: DefId,
span: Span,
) -> hir::GenericBound {
) -> hir::GenericBound<'hir> {
// Compute the `T` in `Future<Output = T>` from the return type.
let output_ty = match output {
FunctionRetTy::Ty(ty) => self.lower_ty(ty, ImplTraitContext::OpaqueTy(Some(fn_def_id))),
@ -2421,7 +2421,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
tpb: &GenericBound,
itctx: ImplTraitContext<'_>,
) -> hir::GenericBound {
) -> hir::GenericBound<'hir> {
match *tpb {
GenericBound::Trait(ref ty, modifier) => hir::GenericBound::Trait(
self.lower_poly_trait_ref(ty, itctx),
@ -2473,7 +2473,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
params: &[GenericParam],
add_bounds: &NodeMap<Vec<GenericBound>>,
mut itctx: ImplTraitContext<'_>,
) -> hir::HirVec<hir::GenericParam> {
) -> hir::HirVec<hir::GenericParam<'hir>> {
params
.iter()
.map(|param| self.lower_generic_param(param, add_bounds, itctx.reborrow()))
@ -2485,7 +2485,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
param: &GenericParam,
add_bounds: &NodeMap<Vec<GenericBound>>,
mut itctx: ImplTraitContext<'_>,
) -> hir::GenericParam {
) -> hir::GenericParam<'hir> {
let mut bounds = self
.with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, |this| {
this.lower_param_bounds(&param.bounds, itctx.reborrow())
@ -2561,7 +2561,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
fn lower_trait_ref(&mut self, p: &TraitRef, itctx: ImplTraitContext<'_>) -> hir::TraitRef {
fn lower_trait_ref(
&mut self,
p: &TraitRef,
itctx: ImplTraitContext<'_>,
) -> hir::TraitRef<'hir> {
let path = match self.lower_qpath(p.ref_id, &None, &p.path, ParamMode::Explicit, itctx) {
hir::QPath::Resolved(None, path) => path,
qpath => bug!("lower_trait_ref: unexpected QPath `{:?}`", qpath),
@ -2573,7 +2577,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
p: &PolyTraitRef,
mut itctx: ImplTraitContext<'_>,
) -> hir::PolyTraitRef {
) -> hir::PolyTraitRef<'hir> {
let bound_generic_params = self.lower_generic_params(
&p.bound_generic_params,
&NodeMap::default(),
@ -2586,7 +2590,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
hir::PolyTraitRef { bound_generic_params, trait_ref, span: p.span }
}
fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_>) -> hir::MutTy {
fn lower_mt(&mut self, mt: &MutTy, itctx: ImplTraitContext<'_>) -> hir::MutTy<'hir> {
hir::MutTy { ty: self.lower_ty(&mt.ty, itctx), mutbl: mt.mutbl }
}
@ -2594,7 +2598,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
bounds: &[GenericBound],
mut itctx: ImplTraitContext<'_>,
) -> hir::GenericBounds {
) -> hir::GenericBounds<'hir> {
bounds.iter().map(|bound| self.lower_param_bound(bound, itctx.reborrow())).collect()
}
@ -3077,9 +3081,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
&mut self,
span: Span,
components: &[Symbol],
params: Option<P<hir::GenericArgs>>,
params: Option<P<hir::GenericArgs<'hir>>>,
is_value: bool,
) -> hir::Path {
) -> hir::Path<'hir> {
let ns = if is_value { Namespace::ValueNS } else { Namespace::TypeNS };
let (path, res) = self.resolver.resolve_str_path(span, self.crate_root, components, ns);
@ -3106,7 +3110,12 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
}
fn ty_path(&mut self, mut hir_id: hir::HirId, span: Span, qpath: hir::QPath) -> hir::Ty {
fn ty_path(
&mut self,
mut hir_id: hir::HirId,
span: Span,
qpath: hir::QPath<'hir>,
) -> hir::Ty<'hir> {
let kind = match qpath {
hir::QPath::Resolved(None, path) => {
// Turn trait object paths into `TyKind::TraitObject` instead.

2
src/librustc/hir/lowering/expr.rs
View file

@ -1338,7 +1338,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&mut self,
span: Span,
components: &[Symbol],
params: Option<P<hir::GenericArgs>>,
params: Option<P<hir::GenericArgs<'hir>>>,
attrs: AttrVec,
) -> hir::Expr<'hir> {
let path = self.std_path(span, components, params, true);

20
src/librustc/hir/lowering/item.rs
View file

@ -258,7 +258,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
id: NodeId,
ident: &mut Ident,
attrs: &'hir [Attribute],
vis: &mut hir::Visibility,
vis: &mut hir::Visibility<'hir>,
i: &ItemKind,
) -> hir::ItemKind<'hir> {
match *i {
@ -466,7 +466,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
tree: &UseTree,
prefix: &Path,
id: NodeId,
vis: &mut hir::Visibility,
vis: &mut hir::Visibility<'hir>,
ident: &mut Ident,
attrs: &'hir [Attribute],
) -> hir::ItemKind<'hir> {
@ -635,7 +635,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
/// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated
/// many times in the HIR tree; for each occurrence, we need to assign distinct
/// `NodeId`s. (See, e.g., #56128.)
fn rebuild_use_path(&mut self, path: &hir::Path) -> hir::Path {
fn rebuild_use_path(&mut self, path: &hir::Path<'hir>) -> hir::Path<'hir> {
debug!("rebuild_use_path(path = {:?})", path);
let segments = path
.segments
@ -651,7 +651,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
hir::Path { span: path.span, res: path.res, segments }
}
fn rebuild_vis(&mut self, vis: &hir::Visibility) -> hir::Visibility {
fn rebuild_vis(&mut self, vis: &hir::Visibility<'hir>) -> hir::Visibility<'hir> {
let vis_kind = match vis.node {
hir::VisibilityKind::Public => hir::VisibilityKind::Public,
hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
@ -918,7 +918,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
// [1] since `default impl` is not yet implemented, this is always true in impls
}
fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef {
fn lower_impl_item_ref(&mut self, i: &AssocItem) -> hir::ImplItemRef<'hir> {
hir::ImplItemRef {
id: hir::ImplItemId { hir_id: self.lower_node_id(i.id) },
ident: i.ident,
@ -952,7 +952,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&mut self,
v: &Visibility,
explicit_owner: Option<NodeId>,
) -> hir::Visibility {
) -> hir::Visibility<'hir> {
let node = match v.node {
VisibilityKind::Public => hir::VisibilityKind::Public,
VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
@ -1255,7 +1255,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
fn_def_id: DefId,
impl_trait_return_allow: bool,
is_async: Option<NodeId>,
) -> (hir::Generics, hir::FnSig<'hir>) {
) -> (hir::Generics<'hir>, hir::FnSig<'hir>) {
let header = self.lower_fn_header(sig.header);
let (generics, decl) = self.add_in_band_defs(
generics,
@ -1316,7 +1316,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
&mut self,
generics: &Generics,
itctx: ImplTraitContext<'_>,
) -> hir::Generics {
) -> hir::Generics<'hir> {
// Collect `?Trait` bounds in where clause and move them to parameter definitions.
// FIXME: this could probably be done with less rightward drift. It also looks like two
// control paths where `report_error` is called are the only paths that advance to after the
@ -1379,7 +1379,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
}
fn lower_where_clause(&mut self, wc: &WhereClause) -> hir::WhereClause {
fn lower_where_clause(&mut self, wc: &WhereClause) -> hir::WhereClause<'hir> {
self.with_anonymous_lifetime_mode(AnonymousLifetimeMode::ReportError, |this| {
hir::WhereClause {
predicates: wc
@ -1392,7 +1392,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
})
}
fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate {
fn lower_where_predicate(&mut self, pred: &WherePredicate) -> hir::WherePredicate<'hir> {
match *pred {
WherePredicate::BoundPredicate(WhereBoundPredicate {
ref bound_generic_params,

20
src/librustc/hir/map/blocks.rs
View file

@ -109,10 +109,10 @@ impl<'a> Code<'a> {
/// use when implementing FnLikeNode operations.
struct ItemFnParts<'a> {
ident: Ident,
decl: &'a ast::FnDecl,
decl: &'a ast::FnDecl<'a>,
header: ast::FnHeader,
vis: &'a ast::Visibility,
generics: &'a ast::Generics,
vis: &'a ast::Visibility<'a>,
generics: &'a ast::Generics<'a>,
body: ast::BodyId,
id: ast::HirId,
span: Span,
@ -122,7 +122,7 @@ struct ItemFnParts<'a> {
/// These are all the components one can extract from a closure expr
/// for use when implementing FnLikeNode operations.
struct ClosureParts<'a> {
decl: &'a FnDecl,
decl: &'a FnDecl<'a>,
body: ast::BodyId,
id: ast::HirId,
span: Span,
@ -130,7 +130,13 @@ struct ClosureParts<'a> {
}
impl<'a> ClosureParts<'a> {
fn new(d: &'a FnDecl, b: ast::BodyId, id: ast::HirId, s: Span, attrs: &'a [Attribute]) -> Self {
fn new(
d: &'a FnDecl<'a>,
b: ast::BodyId,
id: ast::HirId,
s: Span,
attrs: &'a [Attribute],
) -> Self {
ClosureParts { decl: d, body: b, id, span: s, attrs }
}
}
@ -156,7 +162,7 @@ impl<'a> FnLikeNode<'a> {
)
}
pub fn decl(self) -> &'a FnDecl {
pub fn decl(self) -> &'a FnDecl<'a> {
self.handle(
|i: ItemFnParts<'a>| &*i.decl,
|_, _, sig: &'a ast::FnSig<'a>, _, _, _, _| &sig.decl,
@ -210,7 +216,7 @@ impl<'a> FnLikeNode<'a> {
ast::HirId,
Ident,
&'a ast::FnSig<'a>,
Option<&'a ast::Visibility>,
Option<&'a ast::Visibility<'a>>,
ast::BodyId,
Span,
&'a [Attribute],

16
src/librustc/hir/map/collector.rs
View file

@ -401,7 +401,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
});
}
fn visit_generic_param(&mut self, param: &'hir GenericParam) {
fn visit_generic_param(&mut self, param: &'hir GenericParam<'hir>) {
self.insert(param.span, param.hir_id, Node::GenericParam(param));
intravisit::walk_generic_param(self, param);
}
@ -478,14 +478,14 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
});
}
fn visit_path_segment(&mut self, path_span: Span, path_segment: &'hir PathSegment) {
fn visit_path_segment(&mut self, path_span: Span, path_segment: &'hir PathSegment<'hir>) {
if let Some(hir_id) = path_segment.hir_id {
self.insert(path_span, hir_id, Node::PathSegment(path_segment));
}
intravisit::walk_path_segment(self, path_span, path_segment);
}
fn visit_ty(&mut self, ty: &'hir Ty) {
fn visit_ty(&mut self, ty: &'hir Ty<'hir>) {
self.insert(ty.span, ty.hir_id, Node::Ty(ty));
self.with_parent(ty.hir_id, |this| {
@ -493,7 +493,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
});
}
fn visit_trait_ref(&mut self, tr: &'hir TraitRef) {
fn visit_trait_ref(&mut self, tr: &'hir TraitRef<'hir>) {
self.insert(tr.path.span, tr.hir_ref_id, Node::TraitRef(tr));
self.with_parent(tr.hir_ref_id, |this| {
@ -504,7 +504,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
fn visit_fn(
&mut self,
fk: intravisit::FnKind<'hir>,
fd: &'hir FnDecl,
fd: &'hir FnDecl<'hir>,
b: BodyId,
s: Span,
id: HirId,
@ -529,7 +529,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
self.insert(lifetime.span, lifetime.hir_id, Node::Lifetime(lifetime));
}
fn visit_vis(&mut self, visibility: &'hir Visibility) {
fn visit_vis(&mut self, visibility: &'hir Visibility<'hir>) {
match visibility.node {
VisibilityKind::Public | VisibilityKind::Crate(_) | VisibilityKind::Inherited => {}
VisibilityKind::Restricted { hir_id, .. } => {
@ -550,7 +550,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
});
}
fn visit_variant(&mut self, v: &'hir Variant<'hir>, g: &'hir Generics, item_id: HirId) {
fn visit_variant(&mut self, v: &'hir Variant<'hir>, g: &'hir Generics<'hir>, item_id: HirId) {
self.insert(v.span, v.id, Node::Variant(v));
self.with_parent(v.id, |this| {
// Register the constructor of this variant.
@ -576,7 +576,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
self.visit_nested_trait_item(id);
}
fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef) {
fn visit_impl_item_ref(&mut self, ii: &'hir ImplItemRef<'hir>) {
// Do not visit the duplicate information in ImplItemRef. We want to
// map the actual nodes, not the duplicate ones in the *Ref.
let ImplItemRef { id, ident: _, kind: _, span: _, vis: _, defaultness: _ } = *ii;

2
src/librustc/hir/map/hir_id_validator.rs
View file

@ -161,7 +161,7 @@ impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
self.hir_ids_seen.insert(hir_id.local_id);
}
fn visit_impl_item_ref(&mut self, _: &'hir hir::ImplItemRef) {
fn visit_impl_item_ref(&mut self, _: &'hir hir::ImplItemRef<'hir>) {
// Explicitly do nothing here. ImplItemRefs contain hir::Visibility
// values that actually belong to an ImplItem instead of the ItemKind::Impl
// we are currently in. So for those it's correct that they have a

6
src/librustc/hir/map/mod.rs
View file

@ -43,7 +43,7 @@ impl<'hir> Entry<'hir> {
}
}
fn fn_decl(&self) -> Option<&'hir FnDecl> {
fn fn_decl(&self) -> Option<&'hir FnDecl<'hir>> {
match self.node {
Node::Item(ref item) => match item.kind {
ItemKind::Fn(ref sig, _, _) => Some(&sig.decl),
@ -429,7 +429,7 @@ impl<'hir> Map<'hir> {
self.forest.krate.body(id)
}
pub fn fn_decl_by_hir_id(&self, hir_id: HirId) -> Option<&'hir FnDecl> {
pub fn fn_decl_by_hir_id(&self, hir_id: HirId) -> Option<&'hir FnDecl<'hir>> {
if let Some(entry) = self.find_entry(hir_id) {
entry.fn_decl()
} else {
@ -584,7 +584,7 @@ impl<'hir> Map<'hir> {
self.as_local_hir_id(id).map(|id| self.get(id)) // read recorded by `get`
}
pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics> {
pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics<'hir>> {
self.get_if_local(id).and_then(|node| match node {
Node::ImplItem(ref impl_item) => Some(&impl_item.generics),
Node::TraitItem(ref trait_item) => Some(&trait_item.generics),

306
src/librustc/hir/mod.rs
View file

@ -303,27 +303,27 @@ impl Lifetime {
/// `std::cmp::PartialEq`. It's represented as a sequence of identifiers,
/// along with a bunch of supporting information.
#[derive(RustcEncodable, RustcDecodable, HashStable)]
pub struct Path {
pub struct Path<'hir> {
pub span: Span,
/// The resolution for the path.
pub res: Res,
/// The segments in the path: the things separated by `::`.
pub segments: HirVec<PathSegment>,
pub segments: &'hir [PathSegment<'hir>],
}
impl Path {
impl Path<'_> {
pub fn is_global(&self) -> bool {
!self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
}
}
impl fmt::Debug for Path {
impl fmt::Debug for Path<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "path({})", self)
}
}
impl fmt::Display for Path {
impl fmt::Display for Path<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", print::to_string(print::NO_ANN, |s| s.print_path(self, false)))
}
@ -332,7 +332,7 @@ impl fmt::Display for Path {
/// A segment of a path: an identifier, an optional lifetime, and a set of
/// types.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct PathSegment {
pub struct PathSegment<'hir> {
/// The identifier portion of this path segment.
#[stable_hasher(project(name))]
pub ident: Ident,
@ -349,7 +349,7 @@ pub struct PathSegment {
/// this is more than just simple syntactic sugar; the use of
/// parens affects the region binding rules, so we preserve the
/// distinction.
pub args: Option<P<GenericArgs>>,
pub args: Option<&'hir GenericArgs<'hir>>,
/// Whether to infer remaining type parameters, if any.
/// This only applies to expression and pattern paths, and
@ -358,9 +358,9 @@ pub struct PathSegment {
pub infer_args: bool,
}
impl PathSegment {
impl<'hir> PathSegment<'hir> {
/// Converts an identifier to the corresponding segment.
pub fn from_ident(ident: Ident) -> PathSegment {
pub fn from_ident(ident: Ident) -> PathSegment<'hir> {
PathSegment { ident, hir_id: None, res: None, infer_args: true, args: None }
}
@ -368,7 +368,7 @@ impl PathSegment {
ident: Ident,
hir_id: Option<HirId>,
res: Option<Res>,
args: GenericArgs,
args: GenericArgs<'_>,
infer_args: bool,
) -> Self {
PathSegment {
@ -380,11 +380,11 @@ impl PathSegment {
}
}
pub fn generic_args(&self) -> &GenericArgs {
pub fn generic_args(&self) -> &GenericArgs<'hir> {
if let Some(ref args) = self.args {
args
} else {
const DUMMY: &GenericArgs = &GenericArgs::none();
const DUMMY: &GenericArgs<'_> = &GenericArgs::none();
DUMMY
}
}
@ -397,13 +397,13 @@ pub struct ConstArg {
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum GenericArg {
pub enum GenericArg<'hir> {
Lifetime(Lifetime),
Type(Ty),
Type(Ty<'hir>),
Const(ConstArg),
}
impl GenericArg {
impl GenericArg<'_> {
pub fn span(&self) -> Span {
match self {
GenericArg::Lifetime(l) => l.span,
@ -429,19 +429,19 @@ impl GenericArg {
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct GenericArgs {
pub struct GenericArgs<'hir> {
/// The generic arguments for this path segment.
pub args: HirVec<GenericArg>,
pub args: HirVec<GenericArg<'hir>>,
/// Bindings (equality constraints) on associated types, if present.
/// E.g., `Foo<A = Bar>`.
pub bindings: HirVec<TypeBinding>,
pub bindings: &'hir [TypeBinding<'hir>],
/// Were arguments written in parenthesized form `Fn(T) -> U`?
/// This is required mostly for pretty-printing and diagnostics,
/// but also for changing lifetime elision rules to be "function-like".
pub parenthesized: bool,
}
impl GenericArgs {
impl GenericArgs<'_> {
pub const fn none() -> Self {
Self { args: HirVec::new(), bindings: HirVec::new(), parenthesized: false }
}
@ -450,7 +450,7 @@ impl GenericArgs {
self.args.is_empty() && self.bindings.is_empty() && !self.parenthesized
}
pub fn inputs(&self) -> &[Ty] {
pub fn inputs(&self) -> &[Ty<'_>] {
if self.parenthesized {
for arg in &self.args {
match arg {
@ -499,12 +499,12 @@ pub enum TraitBoundModifier {
/// the "special" built-in traits (see `middle::lang_items`) and
/// detects `Copy`, `Send` and `Sync`.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum GenericBound {
Trait(PolyTraitRef, TraitBoundModifier),
pub enum GenericBound<'hir> {
Trait(PolyTraitRef<'hir>, TraitBoundModifier),
Outlives(Lifetime),
}
impl GenericBound {
impl GenericBound<'_> {
pub fn span(&self) -> Span {
match self {
&GenericBound::Trait(ref t, ..) => t.span,
@ -513,7 +513,7 @@ impl GenericBound {
}
}
pub type GenericBounds = HirVec<GenericBound>;
pub type GenericBounds<'hir> = &'hir [GenericBound<'hir>];
#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum LifetimeParamKind {
@ -535,29 +535,29 @@ pub enum LifetimeParamKind {
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum GenericParamKind {
pub enum GenericParamKind<'hir> {
/// A lifetime definition (e.g., `'a: 'b + 'c + 'd`).
Lifetime {
kind: LifetimeParamKind,
},
Type {
default: Option<P<Ty>>,
default: Option<&'hir Ty<'hir>>,
synthetic: Option<SyntheticTyParamKind>,
},
Const {
ty: P<Ty>,
ty: &'hir Ty<'hir>,
},
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct GenericParam {
pub struct GenericParam<'hir> {
pub hir_id: HirId,
pub name: ParamName,
pub attrs: HirVec<Attribute>,
pub bounds: GenericBounds,
pub attrs: &'hir [Attribute],
pub bounds: GenericBounds<'hir>,
pub span: Span,
pub pure_wrt_drop: bool,
pub kind: GenericParamKind,
pub kind: GenericParamKind<'hir>,
}
#[derive(Default)]
@ -570,14 +570,14 @@ pub struct GenericParamCount {
/// Represents lifetimes and type parameters attached to a declaration
/// of a function, enum, trait, etc.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct Generics {
pub params: HirVec<GenericParam>,
pub where_clause: WhereClause,
pub struct Generics<'hir> {
pub params: HirVec<GenericParam<'hir>>,
pub where_clause: WhereClause<'hir>,
pub span: Span,
}
impl Generics {
pub const fn empty() -> Generics {
impl Generics<'hir> {
pub const fn empty() -> Generics<'hir> {
Generics {
params: HirVec::new(),
where_clause: WhereClause { predicates: HirVec::new(), span: DUMMY_SP },
@ -602,7 +602,7 @@ impl Generics {
own_counts
}
pub fn get_named(&self, name: Symbol) -> Option<&GenericParam> {
pub fn get_named(&self, name: Symbol) -> Option<&GenericParam<'_>> {
for param in &self.params {
if name == param.name.ident().name {
return Some(param);
@ -629,13 +629,13 @@ pub enum SyntheticTyParamKind {
/// A where-clause in a definition.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct WhereClause {
pub predicates: HirVec<WherePredicate>,
pub struct WhereClause<'hir> {
pub predicates: &'hir [WherePredicate<'hir>],
// Only valid if predicates isn't empty.
span: Span,
}
impl WhereClause {
impl WhereClause<'_> {
pub fn span(&self) -> Option<Span> {
if self.predicates.is_empty() { None } else { Some(self.span) }
}
@ -649,16 +649,16 @@ impl WhereClause {
/// A single predicate in a where-clause.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum WherePredicate {
pub enum WherePredicate<'hir> {
/// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`).
BoundPredicate(WhereBoundPredicate),
BoundPredicate(WhereBoundPredicate<'hir>),
/// A lifetime predicate (e.g., `'a: 'b + 'c`).
RegionPredicate(WhereRegionPredicate),
RegionPredicate(WhereRegionPredicate<'hir>),
/// An equality predicate (unsupported).
EqPredicate(WhereEqPredicate),
EqPredicate(WhereEqPredicate<'hir>),
}
impl WherePredicate {
impl WherePredicate<'_> {
pub fn span(&self) -> Span {
match self {
&WherePredicate::BoundPredicate(ref p) => p.span,
@ -670,31 +670,31 @@ impl WherePredicate {
/// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`).
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct WhereBoundPredicate {
pub struct WhereBoundPredicate<'hir> {
pub span: Span,
/// Any generics from a `for` binding.
pub bound_generic_params: HirVec<GenericParam>,
pub bound_generic_params: &'hir [GenericParam<'hir>],
/// The type being bounded.
pub bounded_ty: P<Ty>,
pub bounded_ty: &'hir Ty<'hir>,
/// Trait and lifetime bounds (e.g., `Clone + Send + 'static`).
pub bounds: GenericBounds,
pub bounds: GenericBounds<'hir>,
}
/// A lifetime predicate (e.g., `'a: 'b + 'c`).
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct WhereRegionPredicate {
pub struct WhereRegionPredicate<'hir> {
pub span: Span,
pub lifetime: Lifetime,
pub bounds: GenericBounds,
pub bounds: GenericBounds<'hir>,
}
/// An equality predicate (e.g., `T = int`); currently unsupported.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct WhereEqPredicate {
pub struct WhereEqPredicate<'hir> {
pub hir_id: HirId,
pub span: Span,
pub lhs_ty: P<Ty>,
pub rhs_ty: P<Ty>,
pub lhs_ty: &'hir Ty<'hir>,
pub rhs_ty: &'hir Ty<'hir>,
}
#[derive(RustcEncodable, RustcDecodable, Debug)]
@ -820,7 +820,7 @@ impl Crate<'_> {
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct MacroDef<'hir> {
pub name: Name,
pub vis: Visibility,
pub vis: Visibility<'hir>,
pub attrs: &'hir [Attribute],
pub hir_id: HirId,
pub span: Span,
@ -1003,19 +1003,19 @@ pub enum PatKind<'hir> {
/// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
/// The `bool` is `true` in the presence of a `..`.
Struct(QPath, &'hir [FieldPat<'hir>], bool),
Struct(QPath<'hir>, &'hir [FieldPat<'hir>], bool),
/// A tuple struct/variant pattern `Variant(x, y, .., z)`.
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
/// `0 <= position <= subpats.len()`
TupleStruct(QPath, &'hir [&'hir Pat<'hir>], Option<usize>),
TupleStruct(QPath<'hir>, &'hir [&'hir Pat<'hir>], Option<usize>),
/// An or-pattern `A | B | C`.
/// Invariant: `pats.len() >= 2`.
Or(&'hir [&'hir Pat<'hir>]),
/// A path pattern for an unit struct/variant or a (maybe-associated) constant.
Path(QPath),
Path(QPath<'hir>),
/// A tuple pattern (e.g., `(a, b)`).
/// If the `..` pattern fragment is present, then `Option<usize>` denotes its position.
@ -1258,7 +1258,7 @@ impl StmtKind<'hir> {
pub struct Local<'hir> {
pub pat: &'hir Pat<'hir>,
/// Type annotation, if any (otherwise the type will be inferred).
pub ty: Option<&'hir Ty>,
pub ty: Option<&'hir Ty<'hir>>,
/// Initializer expression to set the value, if any.
pub init: Option<&'hir Expr<'hir>>,
pub hir_id: HirId,
@ -1583,7 +1583,7 @@ pub fn is_range_literal(sm: &SourceMap, expr: &Expr<'_>) -> bool {
// Returns whether the given path represents a (desugared) range,
// either in std or core, i.e. has either a `::std::ops::Range` or
// `::core::ops::Range` prefix.
fn is_range_path(path: &Path) -> bool {
fn is_range_path(path: &Path<'_>) -> bool {
let segs: Vec<_> = path.segments.iter().map(|seg| seg.ident.to_string()).collect();
let segs: Vec<_> = segs.iter().map(|seg| &**seg).collect();
@ -1663,7 +1663,7 @@ pub enum ExprKind<'hir> {
/// the `hir_id` of the `MethodCall` node itself.
///
/// [`type_dependent_def_id`]: ../ty/struct.TypeckTables.html#method.type_dependent_def_id
MethodCall(&'hir PathSegment, Span, &'hir [Expr<'hir>]),
MethodCall(&'hir PathSegment<'hir>, Span, &'hir [Expr<'hir>]),
/// A tuple (e.g., `(a, b, c, d)`).
Tup(&'hir [Expr<'hir>]),
/// A binary operation (e.g., `a + b`, `a * b`).
@ -1673,9 +1673,9 @@ pub enum ExprKind<'hir> {
/// A literal (e.g., `1`, `"foo"`).
Lit(Lit),
/// A cast (e.g., `foo as f64`).
Cast(&'hir Expr<'hir>, &'hir Ty),
Cast(&'hir Expr<'hir>, &'hir Ty<'hir>),
/// A type reference (e.g., `Foo`).
Type(&'hir Expr<'hir>, &'hir Ty),
Type(&'hir Expr<'hir>, &'hir Ty<'hir>),
/// Wraps the expression in a terminating scope.
/// This makes it semantically equivalent to `{ let _t = expr; _t }`.
///
@ -1695,7 +1695,7 @@ pub enum ExprKind<'hir> {
///
/// This may also be a generator literal or an `async block` as indicated by the
/// `Option<Movability>`.
Closure(CaptureBy, &'hir FnDecl, BodyId, Span, Option<Movability>),
Closure(CaptureBy, &'hir FnDecl<'hir>, BodyId, Span, Option<Movability>),
/// A block (e.g., `'label: { ... }`).
Block(&'hir Block<'hir>, Option<Label>),
@ -1711,7 +1711,7 @@ pub enum ExprKind<'hir> {
Index(&'hir Expr<'hir>, &'hir Expr<'hir>),
/// Path to a definition, possibly containing lifetime or type parameters.
Path(QPath),
Path(QPath<'hir>),
/// A referencing operation (i.e., `&a` or `&mut a`).
AddrOf(BorrowKind, Mutability, &'hir Expr<'hir>),
@ -1729,7 +1729,7 @@ pub enum ExprKind<'hir> {
///
/// E.g., `Foo {x: 1, y: 2}`, or `Foo {x: 1, .. base}`,
/// where `base` is the `Option<Expr>`.
Struct(&'hir QPath, &'hir [Field<'hir>], Option<&'hir Expr<'hir>>),
Struct(&'hir QPath<'hir>, &'hir [Field<'hir>], Option<&'hir Expr<'hir>>),
/// An array literal constructed from one repeated element.
///
@ -1750,14 +1750,14 @@ pub enum ExprKind<'hir> {
///
/// [`qpath_res`]: ../ty/struct.TypeckTables.html#method.qpath_res
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum QPath {
pub enum QPath<'hir> {
/// Path to a definition, optionally "fully-qualified" with a `Self`
/// type, if the path points to an associated item in a trait.
///
/// E.g., an unqualified path like `Clone::clone` has `None` for `Self`,
/// while `<Vec<T> as Clone>::clone` has `Some(Vec<T>)` for `Self`,
/// even though they both have the same two-segment `Clone::clone` `Path`.
Resolved(Option<P<Ty>>, P<Path>),
Resolved(Option<&'hir Ty<'hir>>, &'hir Path<'hir>),
/// Type-related paths (e.g., `<T>::default` or `<T>::Output`).
/// Will be resolved by type-checking to an associated item.
@ -1765,7 +1765,7 @@ pub enum QPath {
/// UFCS source paths can desugar into this, with `Vec::new` turning into
/// `<Vec>::new`, and `T::X::Y::method` into `<<<T>::X>::Y>::method`,
/// the `X` and `Y` nodes each being a `TyKind::Path(QPath::TypeRelative(..))`.
TypeRelative(P<Ty>, P<PathSegment>),
TypeRelative(&'hir Ty<'hir>, &'hir PathSegment<'hir>),
}
/// Hints at the original code for a let statement.
@ -1909,8 +1909,8 @@ impl From<GeneratorKind> for YieldSource {
// N.B., if you change this, you'll probably want to change the corresponding
// type structure in middle/ty.rs as well.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct MutTy {
pub ty: P<Ty>,
pub struct MutTy<'hir> {
pub ty: &'hir Ty<'hir>,
pub mutbl: Mutability,
}
@ -1919,7 +1919,7 @@ pub struct MutTy {
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct FnSig<'hir> {
pub header: FnHeader,
pub decl: &'hir FnDecl,
pub decl: &'hir FnDecl<'hir>,
}
// The bodies for items are stored "out of line", in a separate
@ -1939,7 +1939,7 @@ pub struct TraitItem<'hir> {
pub ident: Ident,
pub hir_id: HirId,
pub attrs: &'hir [Attribute],
pub generics: Generics,
pub generics: Generics<'hir>,
pub kind: TraitItemKind<'hir>,
pub span: Span,
}
@ -1958,12 +1958,12 @@ pub enum TraitMethod<'hir> {
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum TraitItemKind<'hir> {
/// An associated constant with an optional value (otherwise `impl`s must contain a value).
Const(&'hir Ty, Option<BodyId>),
Const(&'hir Ty<'hir>, Option<BodyId>),
/// A method with an optional body.
Method(FnSig<'hir>, TraitMethod<'hir>),
/// An associated type with (possibly empty) bounds and optional concrete
/// type.
Type(GenericBounds, Option<&'hir Ty>),
Type(GenericBounds<'hir>, Option<&'hir Ty<'hir>>),
}
// The bodies for items are stored "out of line", in a separate
@ -1979,10 +1979,10 @@ pub struct ImplItemId {
pub struct ImplItem<'hir> {
pub ident: Ident,
pub hir_id: HirId,
pub vis: Visibility,
pub vis: Visibility<'hir>,
pub defaultness: Defaultness,
pub attrs: &'hir [Attribute],
pub generics: Generics,
pub generics: Generics<'hir>,
pub kind: ImplItemKind<'hir>,
pub span: Span,
}
@ -1992,13 +1992,13 @@ pub struct ImplItem<'hir> {
pub enum ImplItemKind<'hir> {
/// An associated constant of the given type, set to the constant result
/// of the expression.
Const(&'hir Ty, BodyId),
Const(&'hir Ty<'hir>, BodyId),
/// A method implementation with the given signature and body.
Method(FnSig<'hir>, BodyId),
/// An associated type.
TyAlias(&'hir Ty),
TyAlias(&'hir Ty<'hir>),
/// An associated `type = impl Trait`.
OpaqueTy(GenericBounds),
OpaqueTy(GenericBounds<'hir>),
}
/// Bind a type to an associated type (i.e., `A = Foo`).
@ -2017,25 +2017,25 @@ pub enum ImplItemKind<'hir> {
/// }
/// ```
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct TypeBinding {
pub struct TypeBinding<'hir> {
pub hir_id: HirId,
#[stable_hasher(project(name))]
pub ident: Ident,
pub kind: TypeBindingKind,
pub kind: TypeBindingKind<'hir>,
pub span: Span,
}
// Represents the two kinds of type bindings.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum TypeBindingKind {
pub enum TypeBindingKind<'hir> {
/// E.g., `Foo<Bar: Send>`.
Constraint { bounds: HirVec<GenericBound> },
Constraint { bounds: &'hir [GenericBound<'hir>] },
/// E.g., `Foo<Bar = ()>`.
Equality { ty: P<Ty> },
Equality { ty: &'hir Ty<'hir> },
}
impl TypeBinding {
pub fn ty(&self) -> &Ty {
impl TypeBinding<'_> {
pub fn ty(&self) -> &Ty<'_> {
match self.kind {
TypeBindingKind::Equality { ref ty } => ty,
_ => bug!("expected equality type binding for parenthesized generic args"),
@ -2044,13 +2044,13 @@ impl TypeBinding {
}
#[derive(RustcEncodable, RustcDecodable)]
pub struct Ty {
pub struct Ty<'hir> {
pub hir_id: HirId,
pub kind: TyKind,
pub kind: TyKind<'hir>,
pub span: Span,
}
impl fmt::Debug for Ty {
impl fmt::Debug for Ty<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "type({})", print::to_string(print::NO_ANN, |s| s.print_type(self)))
}
@ -2068,18 +2068,18 @@ pub enum PrimTy {
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct BareFnTy {
pub struct BareFnTy<'hir> {
pub unsafety: Unsafety,
pub abi: Abi,
pub generic_params: HirVec<GenericParam>,
pub decl: P<FnDecl>,
pub param_names: HirVec<Ident>,
pub generic_params: &'hir [GenericParam<'hir>],
pub decl: &'hir FnDecl<'hir>,
pub param_names: &'hir [Ident],
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct OpaqueTy {
pub generics: Generics,
pub bounds: GenericBounds,
pub struct OpaqueTy<'hir> {
pub generics: Generics<'hir>,
pub bounds: GenericBounds<'hir>,
pub impl_trait_fn: Option<DefId>,
pub origin: OpaqueTyOrigin,
}
@ -2097,35 +2097,35 @@ pub enum OpaqueTyOrigin {
/// The various kinds of types recognized by the compiler.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum TyKind {
pub enum TyKind<'hir> {
/// A variable length slice (i.e., `[T]`).
Slice(P<Ty>),
Slice(&'hir Ty<'hir>),
/// A fixed length array (i.e., `[T; n]`).
Array(P<Ty>, AnonConst),
Array(&'hir Ty<'hir>, AnonConst),
/// A raw pointer (i.e., `*const T` or `*mut T`).
Ptr(MutTy),
Ptr(MutTy<'hir>),
/// A reference (i.e., `&'a T` or `&'a mut T`).
Rptr(Lifetime, MutTy),
Rptr(Lifetime, MutTy<'hir>),
/// A bare function (e.g., `fn(usize) -> bool`).
BareFn(P<BareFnTy>),
BareFn(&'hir BareFnTy<'hir>),
/// The never type (`!`).
Never,
/// A tuple (`(A, B, C, D, ...)`).
Tup(HirVec<Ty>),
Tup(&'hir [Ty<'hir>]),
/// A path to a type definition (`module::module::...::Type`), or an
/// associated type (e.g., `<Vec<T> as Trait>::Type` or `<T>::Target`).
///
/// Type parameters may be stored in each `PathSegment`.
Path(QPath),
Path(QPath<'hir>),
/// A type definition itself. This is currently only used for the `type Foo = impl Trait`
/// item that `impl Trait` in return position desugars to.
///
/// The generic argument list contains the lifetimes (and in the future possibly parameters)
/// that are actually bound on the `impl Trait`.
Def(ItemId, HirVec<GenericArg>),
Def(ItemId, &'hir [GenericArg<'hir>]),
/// A trait object type `Bound1 + Bound2 + Bound3`
/// where `Bound` is a trait or a lifetime.
TraitObject(HirVec<PolyTraitRef>, Lifetime),
TraitObject(&'hir [PolyTraitRef<'hir>], Lifetime),
/// Unused for now.
Typeof(AnonConst),
/// `TyKind::Infer` means the type should be inferred instead of it having been
@ -2175,12 +2175,12 @@ pub struct Param<'hir> {
/// Represents the header (not the body) of a function declaration.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct FnDecl {
pub struct FnDecl<'hir> {
/// The types of the function's parameters.
///
/// Additional argument data is stored in the function's [body](Body::parameters).
pub inputs: HirVec<Ty>,
pub output: FunctionRetTy,
pub inputs: &'hir [Ty<'hir>],
pub output: FunctionRetTy<'hir>,
pub c_variadic: bool,
/// Does the function have an implicit self?
pub implicit_self: ImplicitSelfKind,
@ -2256,7 +2256,7 @@ impl Defaultness {
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum FunctionRetTy {
pub enum FunctionRetTy<'hir> {
/// Return type is not specified.
///
/// Functions default to `()` and
@ -2264,10 +2264,10 @@ pub enum FunctionRetTy {
/// type would be inserted.
DefaultReturn(Span),
/// Everything else.
Return(P<Ty>),
Return(&'hir Ty<'hir>),
}
impl fmt::Display for FunctionRetTy {
impl fmt::Display for FunctionRetTy<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Return(ref ty) => print::to_string(print::NO_ANN, |s| s.print_type(ty)).fmt(f),
@ -2276,7 +2276,7 @@ impl fmt::Display for FunctionRetTy {
}
}
impl FunctionRetTy {
impl FunctionRetTy<'_> {
pub fn span(&self) -> Span {
match *self {
DefaultReturn(span) => span,
@ -2350,14 +2350,14 @@ pub enum UseKind {
/// trait being referred to but just a unique `HirId` that serves as a key
/// within the resolution map.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct TraitRef {
pub path: P<Path>,
pub struct TraitRef<'hir> {
pub path: &'hir Path<'hir>,
// Don't hash the `ref_id`. It is tracked via the thing it is used to access.
#[stable_hasher(ignore)]
pub hir_ref_id: HirId,
}
impl TraitRef {
impl TraitRef<'_> {
/// Gets the `DefId` of the referenced trait. It _must_ actually be a trait or trait alias.
pub fn trait_def_id(&self) -> DefId {
match self.path.res {
@ -2372,27 +2372,27 @@ impl TraitRef {
}
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct PolyTraitRef {
pub struct PolyTraitRef<'hir> {
/// The `'a` in `<'a> Foo<&'a T>`.
pub bound_generic_params: HirVec<GenericParam>,
pub bound_generic_params: &'hir [GenericParam<'hir>],
/// The `Foo<&'a T>` in `<'a> Foo<&'a T>`.
pub trait_ref: TraitRef,
pub trait_ref: TraitRef<'hir>,
pub span: Span,
}
pub type Visibility = Spanned<VisibilityKind>;
pub type Visibility<'hir> = Spanned<VisibilityKind<'hir>>;
#[derive(RustcEncodable, RustcDecodable, Debug)]
pub enum VisibilityKind {
pub enum VisibilityKind<'hir> {
Public,
Crate(CrateSugar),
Restricted { path: P<Path>, hir_id: HirId },
Restricted { path: &'hir Path<'hir>, hir_id: HirId },
Inherited,
}
impl VisibilityKind {
impl VisibilityKind<'_> {
pub fn is_pub(&self) -> bool {
match *self {
VisibilityKind::Public => true,
@ -2422,9 +2422,9 @@ pub struct StructField<'hir> {
pub span: Span,
#[stable_hasher(project(name))]
pub ident: Ident,
pub vis: Visibility,
pub vis: Visibility<'hir>,
pub hir_id: HirId,
pub ty: &'hir Ty,
pub ty: &'hir Ty<'hir>,
pub attrs: &'hir [Attribute],
}
@ -2488,7 +2488,7 @@ pub struct Item<'hir> {
pub hir_id: HirId,
pub attrs: &'hir [Attribute],
pub kind: ItemKind<'hir>,
pub vis: Visibility,
pub vis: Visibility<'hir>,
pub span: Span,
}
@ -2521,14 +2521,14 @@ pub enum ItemKind<'hir> {
/// or just
///
/// `use foo::bar::baz;` (with `as baz` implicitly on the right).
Use(&'hir Path, UseKind),
Use(&'hir Path<'hir>, UseKind),
/// A `static` item.
Static(&'hir Ty, Mutability, BodyId),
Static(&'hir Ty<'hir>, Mutability, BodyId),
/// A `const` item.
Const(&'hir Ty, BodyId),
Const(&'hir Ty<'hir>, BodyId),
/// A function declaration.
Fn(FnSig<'hir>, Generics, BodyId),
Fn(FnSig<'hir>, Generics<'hir>, BodyId),
/// A module.
Mod(Mod<'hir>),
/// An external module, e.g. `extern { .. }`.
@ -2536,29 +2536,29 @@ pub enum ItemKind<'hir> {
/// Module-level inline assembly (from `global_asm!`).
GlobalAsm(&'hir GlobalAsm),
/// A type alias, e.g., `type Foo = Bar<u8>`.
TyAlias(&'hir Ty, Generics),
TyAlias(&'hir Ty<'hir>, Generics<'hir>),
/// An opaque `impl Trait` type alias, e.g., `type Foo = impl Bar;`.
OpaqueTy(OpaqueTy),
OpaqueTy(OpaqueTy<'hir>),
/// An enum definition, e.g., `enum Foo<A, B> {C<A>, D<B>}`.
Enum(EnumDef<'hir>, Generics),
Enum(EnumDef<'hir>, Generics<'hir>),
/// A struct definition, e.g., `struct Foo<A> {x: A}`.
Struct(VariantData<'hir>, Generics),
Struct(VariantData<'hir>, Generics<'hir>),
/// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
Union(VariantData<'hir>, Generics),
Union(VariantData<'hir>, Generics<'hir>),
/// A trait definition.
Trait(IsAuto, Unsafety, Generics, GenericBounds, &'hir [TraitItemRef]),
Trait(IsAuto, Unsafety, Generics<'hir>, GenericBounds<'hir>, &'hir [TraitItemRef]),
/// A trait alias.
TraitAlias(Generics, GenericBounds),
TraitAlias(Generics<'hir>, GenericBounds<'hir>),
/// An implementation, e.g., `impl<A> Trait for Foo { .. }`.
Impl(
Unsafety,
ImplPolarity,
Defaultness,
Generics,
Option<TraitRef>, // (optional) trait this impl implements
&'hir Ty, // self
&'hir [ImplItemRef],
Generics<'hir>,
Option<TraitRef<'hir>>, // (optional) trait this impl implements
&'hir Ty<'hir>, // self
&'hir [ImplItemRef<'hir>],
),
}
@ -2593,7 +2593,7 @@ impl ItemKind<'_> {
}
}
pub fn generics(&self) -> Option<&Generics> {
pub fn generics(&self) -> Option<&Generics<'_>> {
Some(match *self {
ItemKind::Fn(_, ref generics, _)
| ItemKind::TyAlias(_, ref generics)
@ -2631,13 +2631,13 @@ pub struct TraitItemRef {
/// passes to find the impl they want without loading the ID (which
/// means fewer edges in the incremental compilation graph).
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub struct ImplItemRef {
pub struct ImplItemRef<'hir> {
pub id: ImplItemId,
#[stable_hasher(project(name))]
pub ident: Ident,
pub kind: AssocItemKind,
pub span: Span,
pub vis: Visibility,
pub vis: Visibility<'hir>,
pub defaultness: Defaultness,
}
@ -2657,16 +2657,16 @@ pub struct ForeignItem<'hir> {
pub kind: ForeignItemKind<'hir>,
pub hir_id: HirId,
pub span: Span,
pub vis: Visibility,
pub vis: Visibility<'hir>,
}
/// An item within an `extern` block.
#[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
pub enum ForeignItemKind<'hir> {
/// A foreign function.
Fn(&'hir FnDecl, &'hir [Ident], Generics),
Fn(&'hir FnDecl<'hir>, &'hir [Ident], Generics<'hir>),
/// A foreign static item (`static ext: u8`).
Static(&'hir Ty, Mutability),
Static(&'hir Ty<'hir>, Mutability),
/// A foreign type.
Type,
}
@ -2837,9 +2837,9 @@ pub enum Node<'hir> {
AnonConst(&'hir AnonConst),
Expr(&'hir Expr<'hir>),
Stmt(&'hir Stmt<'hir>),
PathSegment(&'hir PathSegment),
Ty(&'hir Ty),
TraitRef(&'hir TraitRef),
PathSegment(&'hir PathSegment<'hir>),
Ty(&'hir Ty<'hir>),
TraitRef(&'hir TraitRef<'hir>),
Binding(&'hir Pat<'hir>),
Pat(&'hir Pat<'hir>),
Arm(&'hir Arm<'hir>),
@ -2852,8 +2852,8 @@ pub enum Node<'hir> {
Ctor(&'hir VariantData<'hir>),
Lifetime(&'hir Lifetime),
GenericParam(&'hir GenericParam),
Visibility(&'hir Visibility),
GenericParam(&'hir GenericParam<'hir>),
Visibility(&'hir Visibility<'hir>),
Crate,
}

70
src/librustc/hir/print.rs
View file

@ -140,7 +140,7 @@ where
printer.s.eof()
}
pub fn visibility_qualified<S: Into<Cow<'static, str>>>(vis: &hir::Visibility, w: S) -> String {
pub fn visibility_qualified<S: Into<Cow<'static, str>>>(vis: &hir::Visibility<'_>, w: S) -> String {
to_string(NO_ANN, |s| {
s.print_visibility(vis);
s.s.word(w)
@ -266,7 +266,7 @@ impl<'a> State<'a> {
}
}
pub fn print_type(&mut self, ty: &hir::Ty) {
pub fn print_type(&mut self, ty: &hir::Ty<'_>) {
self.maybe_print_comment(ty.span.lo());
self.ibox(0);
match ty.kind {
@ -398,9 +398,9 @@ impl<'a> State<'a> {
fn print_associated_const(
&mut self,
ident: ast::Ident,
ty: &hir::Ty,
ty: &hir::Ty<'_>,
default: Option<hir::BodyId>,
vis: &hir::Visibility,
vis: &hir::Visibility<'_>,
) {
self.s.word(visibility_qualified(vis, ""));
self.word_space("const");
@ -418,8 +418,8 @@ impl<'a> State<'a> {
fn print_associated_type(
&mut self,
ident: ast::Ident,
bounds: Option<&hir::GenericBounds>,
ty: Option<&hir::Ty>,
bounds: Option<&hir::GenericBounds<'_>>,
ty: Option<&hir::Ty<'_>>,
) {
self.word_space("type");
self.print_ident(ident);
@ -437,7 +437,7 @@ impl<'a> State<'a> {
fn print_item_type(
&mut self,
item: &hir::Item<'_>,
generics: &hir::Generics,
generics: &hir::Generics<'_>,
inner: impl Fn(&mut Self),
) {
self.head(visibility_qualified(&item.vis, "type"));
@ -682,11 +682,11 @@ impl<'a> State<'a> {
self.ann.post(self, AnnNode::Item(item))
}
pub fn print_trait_ref(&mut self, t: &hir::TraitRef) {
pub fn print_trait_ref(&mut self, t: &hir::TraitRef<'_>) {
self.print_path(&t.path, false)
}
fn print_formal_generic_params(&mut self, generic_params: &[hir::GenericParam]) {
fn print_formal_generic_params(&mut self, generic_params: &[hir::GenericParam<'_>]) {
if !generic_params.is_empty() {
self.s.word("for");
self.print_generic_params(generic_params);
@ -694,7 +694,7 @@ impl<'a> State<'a> {
}
}
fn print_poly_trait_ref(&mut self, t: &hir::PolyTraitRef) {
fn print_poly_trait_ref(&mut self, t: &hir::PolyTraitRef<'_>) {
self.print_formal_generic_params(&t.bound_generic_params);
self.print_trait_ref(&t.trait_ref)
}
@ -702,10 +702,10 @@ impl<'a> State<'a> {
pub fn print_enum_def(
&mut self,
enum_definition: &hir::EnumDef<'_>,
generics: &hir::Generics,
generics: &hir::Generics<'_>,
name: ast::Name,
span: syntax_pos::Span,
visibility: &hir::Visibility,
visibility: &hir::Visibility<'_>,
) {
self.head(visibility_qualified(visibility, "enum"));
self.print_name(name);
@ -730,7 +730,7 @@ impl<'a> State<'a> {
self.bclose(span)
}
pub fn print_visibility(&mut self, vis: &hir::Visibility) {
pub fn print_visibility(&mut self, vis: &hir::Visibility<'_>) {
match vis.node {
hir::VisibilityKind::Public => self.word_nbsp("pub"),
hir::VisibilityKind::Crate(ast::CrateSugar::JustCrate) => self.word_nbsp("crate"),
@ -761,7 +761,7 @@ impl<'a> State<'a> {
pub fn print_struct(
&mut self,
struct_def: &hir::VariantData<'_>,
generics: &hir::Generics,
generics: &hir::Generics<'_>,
name: ast::Name,
span: syntax_pos::Span,
print_finalizer: bool,
@ -823,8 +823,8 @@ impl<'a> State<'a> {
&mut self,
ident: ast::Ident,
m: &hir::FnSig<'_>,
generics: &hir::Generics,
vis: &hir::Visibility,
generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[ast::Ident],
body_id: Option<hir::BodyId>,
) {
@ -1044,7 +1044,7 @@ impl<'a> State<'a> {
fn print_expr_struct(
&mut self,
qpath: &hir::QPath,
qpath: &hir::QPath<'_>,
fields: &[hir::Field<'_>],
wth: &Option<&'hir hir::Expr<'_>>,
) {
@ -1103,7 +1103,7 @@ impl<'a> State<'a> {
self.print_call_post(args)
}
fn print_expr_method_call(&mut self, segment: &hir::PathSegment, args: &[hir::Expr<'_>]) {
fn print_expr_method_call(&mut self, segment: &hir::PathSegment<'_>, args: &[hir::Expr<'_>]) {
let base_args = &args[1..];
self.print_expr_maybe_paren(&args[0], parser::PREC_POSTFIX);
self.s.word(".");
@ -1440,7 +1440,7 @@ impl<'a> State<'a> {
self.print_expr(coll)
}
pub fn print_path(&mut self, path: &hir::Path, colons_before_params: bool) {
pub fn print_path(&mut self, path: &hir::Path<'_>, colons_before_params: bool) {
self.maybe_print_comment(path.span.lo());
for (i, segment) in path.segments.iter().enumerate() {
@ -1458,14 +1458,14 @@ impl<'a> State<'a> {
}
}
pub fn print_path_segment(&mut self, segment: &hir::PathSegment) {
pub fn print_path_segment(&mut self, segment: &hir::PathSegment<'_>) {
if segment.ident.name != kw::PathRoot {
self.print_ident(segment.ident);
self.print_generic_args(segment.generic_args(), segment.infer_args, false);
}
}
pub fn print_qpath(&mut self, qpath: &hir::QPath, colons_before_params: bool) {
pub fn print_qpath(&mut self, qpath: &hir::QPath<'_>, colons_before_params: bool) {
match *qpath {
hir::QPath::Resolved(None, ref path) => self.print_path(path, colons_before_params),
hir::QPath::Resolved(Some(ref qself), ref path) => {
@ -1523,7 +1523,7 @@ impl<'a> State<'a> {
fn print_generic_args(
&mut self,
generic_args: &hir::GenericArgs,
generic_args: &hir::GenericArgs<'_>,
infer_args: bool,
colons_before_params: bool,
) {
@ -1814,11 +1814,11 @@ impl<'a> State<'a> {
pub fn print_fn(
&mut self,
decl: &hir::FnDecl,
decl: &hir::FnDecl<'_>,
header: hir::FnHeader,
name: Option<ast::Name>,
generics: &hir::Generics,
vis: &hir::Visibility,
generics: &hir::Generics<'_>,
vis: &hir::Visibility<'_>,
arg_names: &[ast::Ident],
body_id: Option<hir::BodyId>,
) {
@ -1858,7 +1858,7 @@ impl<'a> State<'a> {
self.print_where_clause(&generics.where_clause)
}
fn print_closure_params(&mut self, decl: &hir::FnDecl, body_id: hir::BodyId) {
fn print_closure_params(&mut self, decl: &hir::FnDecl<'_>, body_id: hir::BodyId) {
self.s.word("|");
let mut i = 0;
self.commasep(Inconsistent, &decl.inputs, |s, ty| {
@ -1903,7 +1903,7 @@ impl<'a> State<'a> {
pub fn print_bounds<'b>(
&mut self,
prefix: &'static str,
bounds: impl IntoIterator<Item = &'b hir::GenericBound>,
bounds: impl IntoIterator<Item = &'b hir::GenericBound<'b>>,
) {
let mut first = true;
for bound in bounds {
@ -1933,7 +1933,7 @@ impl<'a> State<'a> {
}
}
pub fn print_generic_params(&mut self, generic_params: &[GenericParam]) {
pub fn print_generic_params(&mut self, generic_params: &[GenericParam<'_>]) {
if !generic_params.is_empty() {
self.s.word("<");
@ -1943,7 +1943,7 @@ impl<'a> State<'a> {
}
}
pub fn print_generic_param(&mut self, param: &GenericParam) {
pub fn print_generic_param(&mut self, param: &GenericParam<'_>) {
if let GenericParamKind::Const { .. } = param.kind {
self.word_space("const");
}
@ -1986,7 +1986,7 @@ impl<'a> State<'a> {
self.print_ident(lifetime.name.ident())
}
pub fn print_where_clause(&mut self, where_clause: &hir::WhereClause) {
pub fn print_where_clause(&mut self, where_clause: &hir::WhereClause<'_>) {
if where_clause.predicates.is_empty() {
return;
}
@ -2056,12 +2056,12 @@ impl<'a> State<'a> {
}
}
pub fn print_mt(&mut self, mt: &hir::MutTy, print_const: bool) {
pub fn print_mt(&mut self, mt: &hir::MutTy<'_>, print_const: bool) {
self.print_mutability(mt.mutbl, print_const);
self.print_type(&mt.ty)
}
pub fn print_fn_output(&mut self, decl: &hir::FnDecl) {
pub fn print_fn_output(&mut self, decl: &hir::FnDecl<'_>) {
if let hir::DefaultReturn(..) = decl.output {
return;
}
@ -2085,9 +2085,9 @@ impl<'a> State<'a> {
&mut self,
abi: Abi,
unsafety: hir::Unsafety,
decl: &hir::FnDecl,
decl: &hir::FnDecl<'_>,
name: Option<ast::Name>,
generic_params: &[hir::GenericParam],
generic_params: &[hir::GenericParam<'_>],
arg_names: &[ast::Ident],
) {
self.ibox(INDENT_UNIT);
@ -2164,7 +2164,7 @@ impl<'a> State<'a> {
}
}
pub fn print_fn_header_info(&mut self, header: hir::FnHeader, vis: &hir::Visibility) {
pub fn print_fn_header_info(&mut self, header: hir::FnHeader, vis: &hir::Visibility<'_>) {
self.s.word(visibility_qualified(vis, ""));
match header.constness {

2
src/librustc/hir/upvars.rs
View file

@ -73,7 +73,7 @@ impl Visitor<'tcx> for CaptureCollector<'a, 'tcx> {
NestedVisitorMap::None
}
fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {
fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
if let Res::Local(var_id) = path.res {
self.visit_local_use(var_id, path.span);
}

4
src/librustc/ich/impls_hir.rs
View file

@ -106,7 +106,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::ImplItemId {
}
}
impl<'a> HashStable<StableHashingContext<'a>> for hir::Ty {
impl<'a> HashStable<StableHashingContext<'a>> for hir::Ty<'_> {
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
hcx.while_hashing_hir_bodies(true, |hcx| {
let hir::Ty { hir_id: _, ref kind, ref span } = *self;
@ -168,7 +168,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for hir::ImplItem<'_> {
}
}
impl<'a> HashStable<StableHashingContext<'a>> for hir::VisibilityKind {
impl<'a> HashStable<StableHashingContext<'a>> for hir::VisibilityKind<'_> {
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
mem::discriminant(self).hash_stable(hcx, hasher);
match *self {

4
src/librustc/infer/error_reporting/need_type_info.rs
View file

@ -107,7 +107,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindLocalByTypeVisitor<'a, 'tcx> {
fn closure_return_type_suggestion(
span: Span,
err: &mut DiagnosticBuilder<'_>,
output: &FunctionRetTy,
output: &FunctionRetTy<'_>,
body: &Body<'_>,
descr: &str,
name: &str,
@ -460,7 +460,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
/// needed, suggest annotating the call, otherwise point out the resulting type of the call.
fn annotate_method_call(
&self,
segment: &hir::PathSegment,
segment: &hir::PathSegment<'_>,
e: &Expr<'_>,
err: &mut DiagnosticBuilder<'_>,
) {

12
src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs
View file

@ -25,7 +25,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
&self,
region: Region<'tcx>,
br: &ty::BoundRegion,
) -> Option<(&hir::Ty, &hir::FnDecl)> {
) -> Option<(&hir::Ty<'_>, &hir::FnDecl<'_>)> {
if let Some(anon_reg) = self.tcx().is_suitable_region(region) {
let def_id = anon_reg.def_id;
if let Some(hir_id) = self.tcx().hir().as_local_hir_id(def_id) {
@ -57,9 +57,9 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
// to the anonymous region.
fn find_component_for_bound_region(
&self,
arg: &'tcx hir::Ty,
arg: &'tcx hir::Ty<'tcx>,
br: &ty::BoundRegion,
) -> Option<&'tcx hir::Ty> {
) -> Option<&'tcx hir::Ty<'tcx>> {
let mut nested_visitor = FindNestedTypeVisitor {
tcx: self.tcx(),
bound_region: *br,
@ -85,7 +85,7 @@ struct FindNestedTypeVisitor<'tcx> {
bound_region: ty::BoundRegion,
// The type where the anonymous lifetime appears
// for e.g., Vec<`&u8`> and <`&u8`>
found_type: Option<&'tcx hir::Ty>,
found_type: Option<&'tcx hir::Ty<'tcx>>,
current_index: ty::DebruijnIndex,
}
@ -94,7 +94,7 @@ impl Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {
NestedVisitorMap::OnlyBodies(&self.tcx.hir())
}
fn visit_ty(&mut self, arg: &'tcx hir::Ty) {
fn visit_ty(&mut self, arg: &'tcx hir::Ty<'tcx>) {
match arg.kind {
hir::TyKind::BareFn(_) => {
self.current_index.shift_in(1);
@ -250,7 +250,7 @@ impl Visitor<'tcx> for TyPathVisitor<'tcx> {
}
}
fn visit_ty(&mut self, arg: &'tcx hir::Ty) {
fn visit_ty(&mut self, arg: &'tcx hir::Ty<'tcx>) {
// ignore nested types
//
// If you have a type like `Foo<'a, &Ty>` we

2
src/librustc/infer/error_reporting/nice_region_error/util.rs
View file

@ -106,7 +106,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
&self,
scope_def_id: DefId,
br: ty::BoundRegion,
decl: &hir::FnDecl,
decl: &hir::FnDecl<'_>,
) -> Option<Span> {
let ret_ty = self.tcx().type_of(scope_def_id);
if let ty::FnDef(_, _) = ret_ty.kind {

24
src/librustc/lint/context.rs
View file

@ -452,7 +452,7 @@ pub struct LateContext<'a, 'tcx> {
last_node_with_lint_attrs: hir::HirId,
/// Generic type parameters in scope for the item we are in.
pub generics: Option<&'tcx hir::Generics>,
pub generics: Option<&'tcx hir::Generics<'tcx>>,
/// We are only looking at one module
only_module: bool,
@ -956,7 +956,7 @@ impl<'a, 'tcx, T: LateLintPass<'a, 'tcx>> hir_visit::Visitor<'tcx>
fn visit_fn(
&mut self,
fk: hir_visit::FnKind<'tcx>,
decl: &'tcx hir::FnDecl,
decl: &'tcx hir::FnDecl<'tcx>,
body_id: hir::BodyId,
span: Span,
id: hir::HirId,
@ -976,7 +976,7 @@ impl<'a, 'tcx, T: LateLintPass<'a, 'tcx>> hir_visit::Visitor<'tcx>
&mut self,
s: &'tcx hir::VariantData<'tcx>,
_: ast::Name,
_: &'tcx hir::Generics,
_: &'tcx hir::Generics<'tcx>,
_: hir::HirId,
_: Span,
) {
@ -995,7 +995,7 @@ impl<'a, 'tcx, T: LateLintPass<'a, 'tcx>> hir_visit::Visitor<'tcx>
fn visit_variant(
&mut self,
v: &'tcx hir::Variant<'tcx>,
g: &'tcx hir::Generics,
g: &'tcx hir::Generics<'tcx>,
item_id: hir::HirId,
) {
self.with_lint_attrs(v.id, &v.attrs, |cx| {
@ -1005,7 +1005,7 @@ impl<'a, 'tcx, T: LateLintPass<'a, 'tcx>> hir_visit::Visitor<'tcx>
})
}
fn visit_ty(&mut self, t: &'tcx hir::Ty) {
fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) {
lint_callback!(self, check_ty, t);
hir_visit::walk_ty(self, t);
}
@ -1038,22 +1038,26 @@ impl<'a, 'tcx, T: LateLintPass<'a, 'tcx>> hir_visit::Visitor<'tcx>
hir_visit::walk_arm(self, a);
}
fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam) {
fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
lint_callback!(self, check_generic_param, p);
hir_visit::walk_generic_param(self, p);
}
fn visit_generics(&mut self, g: &'tcx hir::Generics) {
fn visit_generics(&mut self, g: &'tcx hir::Generics<'tcx>) {
lint_callback!(self, check_generics, g);
hir_visit::walk_generics(self, g);
}
fn visit_where_predicate(&mut self, p: &'tcx hir::WherePredicate) {
fn visit_where_predicate(&mut self, p: &'tcx hir::WherePredicate<'tcx>) {
lint_callback!(self, check_where_predicate, p);
hir_visit::walk_where_predicate(self, p);
}
fn visit_poly_trait_ref(&mut self, t: &'tcx hir::PolyTraitRef, m: hir::TraitBoundModifier) {
fn visit_poly_trait_ref(
&mut self,
t: &'tcx hir::PolyTraitRef<'tcx>,
m: hir::TraitBoundModifier,
) {
lint_callback!(self, check_poly_trait_ref, t, m);
hir_visit::walk_poly_trait_ref(self, t, m);
}
@ -1089,7 +1093,7 @@ impl<'a, 'tcx, T: LateLintPass<'a, 'tcx>> hir_visit::Visitor<'tcx>
hir_visit::walk_lifetime(self, lt);
}
fn visit_path(&mut self, p: &'tcx hir::Path, id: hir::HirId) {
fn visit_path(&mut self, p: &'tcx hir::Path<'tcx>, id: hir::HirId) {
lint_callback!(self, check_path, p, id);
hir_visit::walk_path(self, p);
}

10
src/librustc/lint/internal.rs
View file

@ -76,7 +76,7 @@ declare_lint_pass!(TyTyKind => [
]);
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TyTyKind {
fn check_path(&mut self, cx: &LateContext<'_, '_>, path: &'tcx Path, _: HirId) {
fn check_path(&mut self, cx: &LateContext<'_, '_>, path: &'tcx Path<'tcx>, _: HirId) {
let segments = path.segments.iter().rev().skip(1).rev();
if let Some(last) = segments.last() {
@ -94,7 +94,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TyTyKind {
}
}
fn check_ty(&mut self, cx: &LateContext<'_, '_>, ty: &'tcx Ty) {
fn check_ty(&mut self, cx: &LateContext<'_, '_>, ty: &'tcx Ty<'tcx>) {
match &ty.kind {
TyKind::Path(qpath) => {
if let QPath::Resolved(_, path) = qpath {
@ -159,7 +159,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TyTyKind {
}
}
fn lint_ty_kind_usage(cx: &LateContext<'_, '_>, segment: &PathSegment) -> bool {
fn lint_ty_kind_usage(cx: &LateContext<'_, '_>, segment: &PathSegment<'_>) -> bool {
if let Some(res) = segment.res {
if let Some(did) = res.opt_def_id() {
return cx.tcx.is_diagnostic_item(sym::TyKind, did);
@ -169,7 +169,7 @@ fn lint_ty_kind_usage(cx: &LateContext<'_, '_>, segment: &PathSegment) -> bool {
false
}
fn is_ty_or_ty_ctxt(cx: &LateContext<'_, '_>, ty: &Ty) -> Option<String> {
fn is_ty_or_ty_ctxt(cx: &LateContext<'_, '_>, ty: &Ty<'_>) -> Option<String> {
match &ty.kind {
TyKind::Path(qpath) => {
if let QPath::Resolved(_, path) = qpath {
@ -187,7 +187,7 @@ fn is_ty_or_ty_ctxt(cx: &LateContext<'_, '_>, ty: &Ty) -> Option<String> {
None
}
fn gen_args(segment: &PathSegment) -> String {
fn gen_args(segment: &PathSegment<'_>) -> String {
if let Some(args) = &segment.args {
let lifetimes = args
.args

18
src/librustc/lint/mod.rs
View file

@ -107,20 +107,20 @@ macro_rules! late_lint_methods {
fn check_pat(a: &$hir hir::Pat<$hir>);
fn check_expr(a: &$hir hir::Expr<$hir>);
fn check_expr_post(a: &$hir hir::Expr<$hir>);
fn check_ty(a: &$hir hir::Ty);
fn check_generic_param(a: &$hir hir::GenericParam);
fn check_generics(a: &$hir hir::Generics);
fn check_where_predicate(a: &$hir hir::WherePredicate);
fn check_poly_trait_ref(a: &$hir hir::PolyTraitRef, b: hir::TraitBoundModifier);
fn check_ty(a: &$hir hir::Ty<$hir>);
fn check_generic_param(a: &$hir hir::GenericParam<$hir>);
fn check_generics(a: &$hir hir::Generics<$hir>);
fn check_where_predicate(a: &$hir hir::WherePredicate<$hir>);
fn check_poly_trait_ref(a: &$hir hir::PolyTraitRef<$hir>, b: hir::TraitBoundModifier);
fn check_fn(
a: hir::intravisit::FnKind<$hir>,
b: &$hir hir::FnDecl,
b: &$hir hir::FnDecl<$hir>,
c: &$hir hir::Body<$hir>,
d: Span,
e: hir::HirId);
fn check_fn_post(
a: hir::intravisit::FnKind<$hir>,
b: &$hir hir::FnDecl,
b: &$hir hir::FnDecl<$hir>,
c: &$hir hir::Body<$hir>,
d: Span,
e: hir::HirId
@ -135,7 +135,7 @@ macro_rules! late_lint_methods {
fn check_variant(a: &$hir hir::Variant<$hir>);
fn check_variant_post(a: &$hir hir::Variant<$hir>);
fn check_lifetime(a: &$hir hir::Lifetime);
fn check_path(a: &$hir hir::Path, b: hir::HirId);
fn check_path(a: &$hir hir::Path<$hir>, b: hir::HirId);
fn check_attribute(a: &$hir ast::Attribute);
/// Called when entering a syntax node that can have lint attributes such
@ -643,7 +643,7 @@ impl intravisit::Visitor<'tcx> for LintLevelMapBuilder<'_, 'tcx> {
fn visit_variant(
&mut self,
v: &'tcx hir::Variant<'tcx>,
g: &'tcx hir::Generics,
g: &'tcx hir::Generics<'tcx>,
item_id: hir::HirId,
) {
self.with_lint_attrs(v.id, &v.attrs, |builder| {

69
src/librustc/middle/resolve_lifetime.rs
View file

@ -44,7 +44,7 @@ pub enum LifetimeDefOrigin {
}
impl LifetimeDefOrigin {
fn from_param(param: &GenericParam) -> Self {
fn from_param(param: &GenericParam<'_>) -> Self {
match param.kind {
GenericParamKind::Lifetime { kind } => match kind {
LifetimeParamKind::InBand => LifetimeDefOrigin::InBand,
@ -74,7 +74,7 @@ pub enum Region {
}
impl Region {
fn early(hir_map: &Map<'_>, index: &mut u32, param: &GenericParam) -> (ParamName, Region) {
fn early(hir_map: &Map<'_>, index: &mut u32, param: &GenericParam<'_>) -> (ParamName, Region) {
let i = *index;
*index += 1;
let def_id = hir_map.local_def_id(param.hir_id);
@ -83,7 +83,7 @@ impl Region {
(param.name.modern(), Region::EarlyBound(i, def_id, origin))
}
fn late(hir_map: &Map<'_>, param: &GenericParam) -> (ParamName, Region) {
fn late(hir_map: &Map<'_>, param: &GenericParam<'_>) -> (ParamName, Region) {
let depth = ty::INNERMOST;
let def_id = hir_map.local_def_id(param.hir_id);
let origin = LifetimeDefOrigin::from_param(param);
@ -517,7 +517,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
}
}
fn visit_ty(&mut self, ty: &'tcx hir::Ty) {
fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) {
debug!("visit_ty: id={:?} ty={:?}", ty.hir_id, ty);
debug!("visit_ty: ty.kind={:?}", ty.kind);
match ty.kind {
@ -881,7 +881,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
self.resolve_lifetime_ref(lifetime_ref);
}
fn visit_path(&mut self, path: &'tcx hir::Path, _: hir::HirId) {
fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, _: hir::HirId) {
for (i, segment) in path.segments.iter().enumerate() {
let depth = path.segments.len() - i - 1;
if let Some(ref args) = segment.args {
@ -890,7 +890,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
}
}
fn visit_fn_decl(&mut self, fd: &'tcx hir::FnDecl) {
fn visit_fn_decl(&mut self, fd: &'tcx hir::FnDecl<'tcx>) {
let output = match fd.output {
hir::DefaultReturn(_) => None,
hir::Return(ref ty) => Some(&**ty),
@ -898,7 +898,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
self.visit_fn_like_elision(&fd.inputs, output);
}
fn visit_generics(&mut self, generics: &'tcx hir::Generics) {
fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) {
check_mixed_explicit_and_in_band_defs(self.tcx, &generics.params);
for param in &generics.params {
match param.kind {
@ -976,7 +976,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
fn visit_poly_trait_ref(
&mut self,
trait_ref: &'tcx hir::PolyTraitRef,
trait_ref: &'tcx hir::PolyTraitRef<'tcx>,
_modifier: hir::TraitBoundModifier,
) {
debug!("visit_poly_trait_ref(trait_ref={:?})", trait_ref);
@ -1046,7 +1046,7 @@ fn shadower_label(span: Span) -> Shadower {
fn original_lifetime(span: Span) -> Original {
Original { kind: ShadowKind::Lifetime, span: span }
}
fn shadower_lifetime(param: &hir::GenericParam) -> Shadower {
fn shadower_lifetime(param: &hir::GenericParam<'_>) -> Shadower {
Shadower { kind: ShadowKind::Lifetime, span: param.span }
}
@ -1059,7 +1059,7 @@ impl ShadowKind {
}
}
fn check_mixed_explicit_and_in_band_defs(tcx: TyCtxt<'_>, params: &P<[hir::GenericParam]>) {
fn check_mixed_explicit_and_in_band_defs(tcx: TyCtxt<'_>, params: &P<[hir::GenericParam<'_>]>) {
let lifetime_params: Vec<_> = params
.iter()
.filter_map(|param| match param.kind {
@ -1252,9 +1252,9 @@ fn compute_object_lifetime_defaults(tcx: TyCtxt<'_>) -> HirIdMap<Vec<ObjectLifet
/// for each type parameter.
fn object_lifetime_defaults_for_item(
tcx: TyCtxt<'_>,
generics: &hir::Generics,
generics: &hir::Generics<'_>,
) -> Vec<ObjectLifetimeDefault> {
fn add_bounds(set: &mut Set1<hir::LifetimeName>, bounds: &[hir::GenericBound]) {
fn add_bounds(set: &mut Set1<hir::LifetimeName>, bounds: &[hir::GenericBound<'_>]) {
for bound in bounds {
if let hir::GenericBound::Outlives(ref lifetime) = *bound {
set.insert(lifetime.name.modern());
@ -1368,7 +1368,11 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
/// helper method to determine the span to remove when suggesting the
/// deletion of a lifetime
fn lifetime_deletion_span(&self, name: ast::Ident, generics: &hir::Generics) -> Option<Span> {
fn lifetime_deletion_span(
&self,
name: ast::Ident,
generics: &hir::Generics<'_>,
) -> Option<Span> {
generics.params.iter().enumerate().find_map(|(i, param)| {
if param.name.ident() == name {
let mut in_band = false;
@ -1417,7 +1421,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
let mut remove_use = None;
let mut elide_use = None;
let mut find_arg_use_span = |inputs: &hir::HirVec<hir::Ty>| {
let mut find_arg_use_span = |inputs: &hir::HirVec<hir::Ty<'_>>| {
for input in inputs {
match input.kind {
hir::TyKind::Rptr(lt, _) => {
@ -1656,8 +1660,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
fn visit_early_late<F>(
&mut self,
parent_id: Option<hir::HirId>,
decl: &'tcx hir::FnDecl,
generics: &'tcx hir::Generics,
decl: &'tcx hir::FnDecl<'tcx>,
generics: &'tcx hir::Generics<'tcx>,
walk: F,
) where
F: for<'b, 'c> FnOnce(&'b mut LifetimeContext<'c, 'tcx>),
@ -1854,7 +1858,12 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
}
}
fn visit_segment_args(&mut self, res: Res, depth: usize, generic_args: &'tcx hir::GenericArgs) {
fn visit_segment_args(
&mut self,
res: Res,
depth: usize,
generic_args: &'tcx hir::GenericArgs<'tcx>,
) {
debug!(
"visit_segment_args(res={:?}, depth={:?}, generic_args={:?})",
res, depth, generic_args,
@ -2045,7 +2054,11 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
}
}
fn visit_fn_like_elision(&mut self, inputs: &'tcx [hir::Ty], output: Option<&'tcx hir::Ty>) {
fn visit_fn_like_elision(
&mut self,
inputs: &'tcx [hir::Ty<'tcx>],
output: Option<&'tcx hir::Ty<'tcx>>,
) {
debug!("visit_fn_like_elision: enter");
let mut arg_elide = Elide::FreshLateAnon(Cell::new(0));
let arg_scope = Scope::Elision { elide: arg_elide.clone(), s: self.scope };
@ -2125,7 +2138,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
if has_self {
struct SelfVisitor<'a> {
map: &'a NamedRegionMap,
impl_self: Option<&'a hir::TyKind>,
impl_self: Option<&'a hir::TyKind<'a>>,
lifetime: Set1<Region>,
}
@ -2163,7 +2176,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
NestedVisitorMap::None
}
fn visit_ty(&mut self, ty: &'a hir::Ty) {
fn visit_ty(&mut self, ty: &'a hir::Ty<'a>) {
if let hir::TyKind::Rptr(lifetime_ref, ref mt) = ty.kind {
if let hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) = mt.ty.kind
{
@ -2251,7 +2264,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
NestedVisitorMap::None
}
fn visit_ty(&mut self, ty: &hir::Ty) {
fn visit_ty(&mut self, ty: &hir::Ty<'_>) {
if let hir::TyKind::BareFn(_) = ty.kind {
self.outer_index.shift_in(1);
}
@ -2276,7 +2289,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
}
}
fn visit_generic_param(&mut self, param: &hir::GenericParam) {
fn visit_generic_param(&mut self, param: &hir::GenericParam<'_>) {
if let hir::GenericParamKind::Lifetime { .. } = param.kind {
// FIXME(eddyb) Do we want this? It only makes a difference
// if this `for<'a>` lifetime parameter is never used.
@ -2288,7 +2301,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
fn visit_poly_trait_ref(
&mut self,
trait_ref: &hir::PolyTraitRef,
trait_ref: &hir::PolyTraitRef<'_>,
modifier: hir::TraitBoundModifier,
) {
self.outer_index.shift_in(1);
@ -2523,7 +2536,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
fn check_lifetime_params(
&mut self,
old_scope: ScopeRef<'_>,
params: &'tcx [hir::GenericParam],
params: &'tcx [hir::GenericParam<'tcx>],
) {
let lifetimes: Vec<_> = params
.iter()
@ -2617,7 +2630,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
fn check_lifetime_param_for_shadowing(
&self,
mut old_scope: ScopeRef<'_>,
param: &'tcx hir::GenericParam,
param: &'tcx hir::GenericParam<'tcx>,
) {
for label in &self.labels_in_fn {
// FIXME (#24278): non-hygienic comparison
@ -2755,8 +2768,8 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
/// T as Trait<''b>>::Foo` does not constrain `'a` or `'b`.
fn insert_late_bound_lifetimes(
map: &mut NamedRegionMap,
decl: &hir::FnDecl,
generics: &hir::Generics,
decl: &hir::FnDecl<'_>,
generics: &hir::Generics<'_>,
) {
debug!("insert_late_bound_lifetimes(decl={:?}, generics={:?})", decl, generics);
@ -2840,7 +2853,7 @@ fn insert_late_bound_lifetimes(
NestedVisitorMap::None
}
fn visit_ty(&mut self, ty: &'v hir::Ty) {
fn visit_ty(&mut self, ty: &'v hir::Ty<'v>) {
match ty.kind {
hir::TyKind::Path(hir::QPath::Resolved(Some(_), _))
| hir::TyKind::Path(hir::QPath::TypeRelative(..)) => {

6
src/librustc/middle/stability.rs
View file

@ -306,7 +306,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> {
});
}
fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics, item_id: HirId) {
fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics<'tcx>, item_id: HirId) {
self.annotate(var.id, &var.attrs, var.span, AnnotationKind::Required, |v| {
if let Some(ctor_hir_id) = var.data.ctor_hir_id() {
v.annotate(ctor_hir_id, &var.attrs, var.span, AnnotationKind::Required, |_| {});
@ -381,7 +381,7 @@ impl<'a, 'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'a, 'tcx> {
intravisit::walk_impl_item(self, ii);
}
fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics, item_id: HirId) {
fn visit_variant(&mut self, var: &'tcx Variant<'tcx>, g: &'tcx Generics<'tcx>, item_id: HirId) {
self.check_missing_stability(var.id, var.span, "variant");
intravisit::walk_variant(self, var, g, item_id);
}
@ -886,7 +886,7 @@ impl Visitor<'tcx> for Checker<'tcx> {
intravisit::walk_item(self, item);
}
fn visit_path(&mut self, path: &'tcx hir::Path, id: hir::HirId) {
fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, id: hir::HirId) {
if let Some(def_id) = path.res.opt_def_id() {
self.tcx.check_stability(def_id, Some(id), path.span)
}

4
src/librustc/traits/error_reporting.rs
View file

@ -1154,7 +1154,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
};
let suggest_restriction =
|generics: &hir::Generics, msg, err: &mut DiagnosticBuilder<'_>| {
|generics: &hir::Generics<'_>, msg, err: &mut DiagnosticBuilder<'_>| {
let span = generics.where_clause.span_for_predicates_or_empty_place();
if !span.from_expansion() && span.desugaring_kind().is_none() {
err.span_suggestion(
@ -2851,7 +2851,7 @@ impl ArgKind {
/// Suggest restricting a type param with a new bound.
pub fn suggest_constraining_type_param(
generics: &hir::Generics,
generics: &hir::Generics<'_>,
err: &mut DiagnosticBuilder<'_>,
param_name: &str,
constraint: &str,

2
src/librustc/ty/context.rs
View file

@ -464,7 +464,7 @@ impl<'tcx> TypeckTables<'tcx> {
}
/// Returns the final resolution of a `QPath` in an `Expr` or `Pat` node.
pub fn qpath_res(&self, qpath: &hir::QPath, id: hir::HirId) -> Res {
pub fn qpath_res(&self, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res {
match *qpath {
hir::QPath::Resolved(_, ref path) => path.res,
hir::QPath::TypeRelative(..) => self

6
src/librustc/ty/mod.rs
View file

@ -298,7 +298,7 @@ impl<'tcx> DefIdTree for TyCtxt<'tcx> {
}
impl Visibility {
pub fn from_hir(visibility: &hir::Visibility, id: hir::HirId, tcx: TyCtxt<'_>) -> Self {
pub fn from_hir(visibility: &hir::Visibility<'_>, id: hir::HirId, tcx: TyCtxt<'_>) -> Self {
match visibility.node {
hir::VisibilityKind::Public => Visibility::Public,
hir::VisibilityKind::Crate(_) => Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)),
@ -2757,7 +2757,7 @@ impl<'tcx> TyCtxt<'tcx> {
fn associated_item_from_trait_item_ref(
self,
parent_def_id: DefId,
parent_vis: &hir::Visibility,
parent_vis: &hir::Visibility<'_>,
trait_item_ref: &hir::TraitItemRef,
) -> AssocItem {
let def_id = self.hir().local_def_id(trait_item_ref.id.hir_id);
@ -2783,7 +2783,7 @@ impl<'tcx> TyCtxt<'tcx> {
fn associated_item_from_impl_item_ref(
self,
parent_def_id: DefId,
impl_item_ref: &hir::ImplItemRef,
impl_item_ref: &hir::ImplItemRef<'_>,
) -> AssocItem {
let def_id = self.hir().local_def_id(impl_item_ref.id.hir_id);
let (kind, has_self) = match impl_item_ref.kind {

4
src/librustc/ty/wf.rs
View file

@ -694,7 +694,7 @@ pub fn object_region_bounds<'tcx>(
/// Find the span of a generic bound affecting an associated type.
fn get_generic_bound_spans(
generics: &hir::Generics,
generics: &hir::Generics<'_>,
trait_name: Option<&Ident>,
assoc_item_name: Ident,
) -> Vec<Span> {
@ -729,7 +729,7 @@ fn get_generic_bound_spans(
bounds
}
fn is_self_path(kind: &hir::TyKind) -> bool {
fn is_self_path(kind: &hir::TyKind<'_>) -> bool {
match kind {
hir::TyKind::Path(hir::QPath::Resolved(None, path)) => {
let mut s = path.segments.iter();