GenericArg::Const(ct) => self.visit_anon_const(ct),
}
}
- fn visit_assoc_type_binding(&mut self, type_binding: &'ast TypeBinding) {
- walk_assoc_type_binding(self, type_binding)
+ fn visit_assoc_ty_constraint(&mut self, constraint: &'ast AssocTyConstraint) {
+ walk_assoc_ty_constraint(self, constraint)
}
fn visit_attribute(&mut self, attr: &'ast Attribute) {
walk_attribute(self, attr)
match *generic_args {
GenericArgs::AngleBracketed(ref data) => {
walk_list!(visitor, visit_generic_arg, &data.args);
- walk_list!(visitor, visit_assoc_type_binding, &data.bindings);
+ walk_list!(visitor, visit_assoc_ty_constraint, &data.constraints);
}
GenericArgs::Parenthesized(ref data) => {
walk_list!(visitor, visit_ty, &data.inputs);
}
}
-pub fn walk_assoc_type_binding<'a, V: Visitor<'a>>(visitor: &mut V,
- type_binding: &'a TypeBinding) {
- visitor.visit_ident(type_binding.ident);
- visitor.visit_ty(&type_binding.ty);
+pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>(visitor: &mut V,
+ constraint: &'a AssocTyConstraint) {
+ visitor.visit_ident(constraint.ident);
+ match constraint.kind {
+ AssocTyConstraintKind::Equality { ref ty } => {
+ visitor.visit_ty(ty);
+ }
+ AssocTyConstraintKind::Bound { ref bounds } => {
+ walk_list!(visitor, visit_param_bound, bounds);
+ }
+ }
}
pub fn walk_pat<'a, V: Visitor<'a>>(visitor: &mut V, pattern: &'a Pat) {
walk_list!(visitor, visit_attribute, param.attrs.iter());
walk_list!(visitor, visit_param_bound, ¶m.bounds);
match param.kind {
- GenericParamKind::Lifetime => {}
+ GenericParamKind::Lifetime => (),
GenericParamKind::Type { ref default } => walk_list!(visitor, visit_ty, default),
GenericParamKind::Const { ref ty, .. } => visitor.visit_ty(ty),
}
pub fn walk_fn_decl<'a, V: Visitor<'a>>(visitor: &mut V, function_declaration: &'a FnDecl) {
for argument in &function_declaration.inputs {
+ walk_list!(visitor, visit_attribute, argument.attrs.iter());
visitor.visit_pat(&argument.pat);
- visitor.visit_ty(&argument.ty)
+ visitor.visit_ty(&argument.ty);
}
visitor.visit_fn_ret_ty(&function_declaration.output)
}
ExprKind::AddrOf(_, ref subexpression) | ExprKind::Unary(_, ref subexpression) => {
visitor.visit_expr(subexpression)
}
- ExprKind::Lit(_) => {}
ExprKind::Cast(ref subexpression, ref typ) | ExprKind::Type(ref subexpression, ref typ) => {
visitor.visit_expr(subexpression);
visitor.visit_ty(typ)
ExprKind::TryBlock(ref body) => {
visitor.visit_block(body)
}
- ExprKind::Err => {}
+ ExprKind::Lit(_) | ExprKind::Err => {}
}
visitor.visit_expr_post(expression)
pub fn walk_tt<'a, V: Visitor<'a>>(visitor: &mut V, tt: TokenTree) {
match tt {
- TokenTree::Token(_, tok) => visitor.visit_token(tok),
+ TokenTree::Token(token) => visitor.visit_token(token),
TokenTree::Delimited(_, _, tts) => visitor.visit_tts(tts),
}
}