TraitItemKind::Method(_, None) => {
// Ignore patterns in trait methods without bodies
self.with_hir_id_owner(None, |this| {
- visit::walk_trait_item(this, item)
+ visit::walk_assoc_item(this, item)
});
}
_ => self.with_hir_id_owner(Some(item.id), |this| {
- visit::walk_trait_item(this, item);
+ visit::walk_assoc_item(this, item);
})
}
}
fn visit_impl_item(&mut self, item: &'tcx ImplItem) {
self.lctx.allocate_hir_id_counter(item.id);
self.with_hir_id_owner(Some(item.id), |this| {
- visit::walk_impl_item(this, item);
+ visit::walk_assoc_item(this, item);
});
}
lctx.modules.get_mut(&lctx.current_module).unwrap().trait_items.insert(id);
});
- visit::walk_trait_item(self, item);
+ visit::walk_assoc_item(self, item);
}
fn visit_impl_item(&mut self, item: &'tcx ImplItem) {
lctx.impl_items.insert(id, hir_item);
lctx.modules.get_mut(&lctx.current_module).unwrap().impl_items.insert(id);
});
- visit::walk_impl_item(self, item);
+ visit::walk_assoc_item(self, item);
}
}
fn visit_trait_item(&mut self, trait_item: &'a ast::TraitItem) {
self.with_lint_attrs(trait_item.id, &trait_item.attrs, |cx| {
run_early_pass!(cx, check_trait_item, trait_item);
- ast_visit::walk_trait_item(cx, trait_item);
+ ast_visit::walk_assoc_item(cx, trait_item);
run_early_pass!(cx, check_trait_item_post, trait_item);
});
}
fn visit_impl_item(&mut self, impl_item: &'a ast::ImplItem) {
self.with_lint_attrs(impl_item.id, &impl_item.attrs, |cx| {
run_early_pass!(cx, check_impl_item, impl_item);
- ast_visit::walk_impl_item(cx, impl_item);
+ ast_visit::walk_assoc_item(cx, impl_item);
run_early_pass!(cx, check_impl_item_post, impl_item);
});
}
|this| visit::walk_enum_def(this, enum_definition, generics, item_id))
}
- fn visit_impl_item(&mut self, ii: &'a ImplItem) {
+ fn visit_impl_item(&mut self, ii: &'a AssocItem) {
match &ii.kind {
- ImplItemKind::Const(_, body) => {
+ AssocItemKind::Const(_, body) => {
self.check_impl_item_provided(ii.span, body, "constant", " = <expr>;");
}
- ImplItemKind::Method(sig, body) => {
+ AssocItemKind::Method(sig, body) => {
self.check_impl_item_provided(ii.span, body, "function", " { <body> }");
self.check_fn_decl(&sig.decl);
}
- ImplItemKind::TyAlias(bounds, body) => {
+ AssocItemKind::TyAlias(bounds, body) => {
self.check_impl_item_provided(ii.span, body, "type", " = <type>;");
self.check_impl_assoc_type_no_bounds(bounds);
}
_ => {}
}
- visit::walk_impl_item(self, ii);
+ visit::walk_assoc_item(self, ii);
}
- fn visit_trait_item(&mut self, ti: &'a TraitItem) {
+ fn visit_trait_item(&mut self, ti: &'a AssocItem) {
self.invalid_visibility(&ti.vis, None);
self.check_defaultness(ti.span, ti.defaultness);
- visit::walk_trait_item(self, ti);
+ visit::walk_assoc_item(self, ti);
}
}
fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {
self.record("TraitItem", Id::None, ti);
- ast_visit::walk_trait_item(self, ti)
+ ast_visit::walk_assoc_item(self, ti)
}
fn visit_impl_item(&mut self, ii: &'v ast::ImplItem) {
self.record("ImplItem", Id::None, ii);
- ast_visit::walk_impl_item(self, ii)
+ ast_visit::walk_assoc_item(self, ii)
}
fn visit_param_bound(&mut self, bounds: &'v ast::GenericBound) {
let expansion = self.parent_scope.expansion;
self.r.define(parent, item.ident, ns, (res, vis, item.span, expansion));
- visit::walk_trait_item(self, item);
+ visit::walk_assoc_item(self, item);
}
fn visit_impl_item(&mut self, item: &'b ast::ImplItem) {
self.visit_invoc(item.id);
} else {
self.resolve_visibility(&item.vis);
- visit::walk_impl_item(self, item);
+ visit::walk_assoc_item(self, item);
}
}
};
let def = self.create_def(ti.id, def_data, ti.span);
- self.with_parent(def, |this| visit::walk_trait_item(this, ti));
+ self.with_parent(def, |this| visit::walk_assoc_item(this, ti));
}
fn visit_impl_item(&mut self, ii: &'a ImplItem) {
};
let def = self.create_def(ii.id, def_data, ii.span);
- self.with_parent(def, |this| visit::walk_impl_item(this, ii));
+ self.with_parent(def, |this| visit::walk_assoc_item(this, ii));
}
fn visit_pat(&mut self, pat: &'a Pat) {
}
}
TraitItemKind::Method(_, _) => {
- visit::walk_trait_item(this, trait_item)
+ visit::walk_assoc_item(this, trait_item)
}
TraitItemKind::TyAlias(..) => {
- visit::walk_trait_item(this, trait_item)
+ visit::walk_assoc_item(this, trait_item)
}
TraitItemKind::Macro(_) => {
panic!("unexpanded macro in resolve!")
);
this.with_constant_rib(|this| {
- visit::walk_impl_item(this, impl_item)
+ visit::walk_assoc_item(this, impl_item)
});
}
ImplItemKind::Method(..) => {
impl_item.span,
|n, s| MethodNotMemberOfTrait(n, s));
- visit::walk_impl_item(this, impl_item);
+ visit::walk_assoc_item(this, impl_item);
}
ImplItemKind::TyAlias(_, Some(ref ty)) => {
// If this is a trait impl, ensure the type
}
_ => {}
}
- visit::walk_trait_item(self, ti)
+ visit::walk_assoc_item(self, ti)
}
fn visit_impl_item(&mut self, ii: &'a ast::ImplItem) {
}
_ => {}
}
- visit::walk_impl_item(self, ii)
+ visit::walk_assoc_item(self, ii)
}
fn visit_vis(&mut self, vis: &'a ast::Visibility) {
}
fn visit_trait_item(&mut self, ti: &TraitItem) {
self.count += 1;
- walk_trait_item(self, ti)
+ walk_assoc_item(self, ti)
}
fn visit_impl_item(&mut self, ii: &ImplItem) {
self.count += 1;
- walk_impl_item(self, ii)
+ walk_assoc_item(self, ii)
}
fn visit_trait_ref(&mut self, t: &TraitRef) {
self.count += 1;
fn visit_fn(&mut self, fk: FnKind<'ast>, fd: &'ast FnDecl, s: Span, _: NodeId) {
walk_fn(self, fk, fd, s)
}
- fn visit_trait_item(&mut self, ti: &'ast TraitItem) { walk_trait_item(self, ti) }
- fn visit_impl_item(&mut self, ii: &'ast ImplItem) { walk_impl_item(self, ii) }
+ fn visit_trait_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) }
+ fn visit_impl_item(&mut self, i: &'ast AssocItem) { walk_assoc_item(self, i) }
fn visit_trait_ref(&mut self, t: &'ast TraitRef) { walk_trait_ref(self, t) }
fn visit_param_bound(&mut self, bounds: &'ast GenericBound) {
walk_param_bound(self, bounds)
}
}
-pub fn walk_trait_item<'a, V: Visitor<'a>>(visitor: &mut V, trait_item: &'a TraitItem) {
- visitor.visit_vis(&trait_item.vis);
- visitor.visit_ident(trait_item.ident);
- walk_list!(visitor, visit_attribute, &trait_item.attrs);
- visitor.visit_generics(&trait_item.generics);
- match trait_item.kind {
- TraitItemKind::Const(ref ty, ref default) => {
- visitor.visit_ty(ty);
- walk_list!(visitor, visit_expr, default);
- }
- TraitItemKind::Method(ref sig, None) => {
- visitor.visit_fn_header(&sig.header);
- walk_fn_decl(visitor, &sig.decl);
- }
- TraitItemKind::Method(ref sig, Some(ref body)) => {
- visitor.visit_fn(FnKind::Method(trait_item.ident, sig, &trait_item.vis, body),
- &sig.decl, trait_item.span, trait_item.id);
- }
- TraitItemKind::TyAlias(ref bounds, ref default) => {
- walk_list!(visitor, visit_param_bound, bounds);
- walk_list!(visitor, visit_ty, default);
- }
- TraitItemKind::Macro(ref mac) => {
- visitor.visit_mac(mac);
- }
- }
-}
-
-pub fn walk_impl_item<'a, V: Visitor<'a>>(visitor: &mut V, impl_item: &'a ImplItem) {
- visitor.visit_vis(&impl_item.vis);
- visitor.visit_ident(impl_item.ident);
- walk_list!(visitor, visit_attribute, &impl_item.attrs);
- visitor.visit_generics(&impl_item.generics);
- match impl_item.kind {
- ImplItemKind::Const(ref ty, ref expr) => {
+pub fn walk_assoc_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) {
+ visitor.visit_vis(&item.vis);
+ visitor.visit_ident(item.ident);
+ walk_list!(visitor, visit_attribute, &item.attrs);
+ visitor.visit_generics(&item.generics);
+ match item.kind {
+ AssocItemKind::Const(ref ty, ref expr) => {
visitor.visit_ty(ty);
walk_list!(visitor, visit_expr, expr);
}
- ImplItemKind::Method(ref sig, None) => {
+ AssocItemKind::Method(ref sig, None) => {
visitor.visit_fn_header(&sig.header);
walk_fn_decl(visitor, &sig.decl);
}
- ImplItemKind::Method(ref sig, Some(ref body)) => {
- visitor.visit_fn(FnKind::Method(impl_item.ident, sig, &impl_item.vis, body),
- &sig.decl, impl_item.span, impl_item.id);
+ AssocItemKind::Method(ref sig, Some(ref body)) => {
+ visitor.visit_fn(FnKind::Method(item.ident, sig, &item.vis, body),
+ &sig.decl, item.span, item.id);
}
- ImplItemKind::TyAlias(ref bounds, ref ty) => {
+ AssocItemKind::TyAlias(ref bounds, ref ty) => {
walk_list!(visitor, visit_param_bound, bounds);
walk_list!(visitor, visit_ty, ty);
}
- ImplItemKind::Macro(ref mac) => {
+ AssocItemKind::Macro(ref mac) => {
visitor.visit_mac(mac);
}
}