use crate::ast::*;
use crate::token::Token;
-use crate::tokenstream::{TokenTree, TokenStream};
+use crate::tokenstream::{TokenStream, TokenTree};
-use syntax_pos::Span;
+use rustc_span::Span;
#[derive(Copy, Clone)]
pub enum FnKind<'a> {
ItemFn(Ident, &'a FnHeader, &'a Visibility, &'a Block),
/// E.g., `fn foo(&self)`.
- Method(Ident, &'a FnSig, Option<&'a Visibility>, &'a Block),
+ Method(Ident, &'a FnSig, &'a Visibility, &'a Block),
/// E.g., `|x, y| body`.
Closure(&'a Expr),
fn visit_mod(&mut self, m: &'ast Mod, _s: Span, _attrs: &[Attribute], _n: NodeId) {
walk_mod(self, m);
}
- fn visit_foreign_item(&mut self, i: &'ast ForeignItem) { walk_foreign_item(self, i) }
- fn visit_global_asm(&mut self, ga: &'ast GlobalAsm) { walk_global_asm(self, ga) }
- fn visit_item(&mut self, i: &'ast Item) { walk_item(self, i) }
- fn visit_local(&mut self, l: &'ast Local) { walk_local(self, l) }
- fn visit_block(&mut self, b: &'ast Block) { walk_block(self, b) }
- fn visit_stmt(&mut self, s: &'ast Stmt) { walk_stmt(self, s) }
- fn visit_param(&mut self, param: &'ast Param) { walk_param(self, param) }
- fn visit_arm(&mut self, a: &'ast Arm) { walk_arm(self, a) }
- fn visit_pat(&mut self, p: &'ast Pat) { walk_pat(self, p) }
- fn visit_anon_const(&mut self, c: &'ast AnonConst) { walk_anon_const(self, c) }
- fn visit_expr(&mut self, ex: &'ast Expr) { walk_expr(self, ex) }
- fn visit_expr_post(&mut self, _ex: &'ast Expr) { }
- fn visit_ty(&mut self, t: &'ast Ty) { walk_ty(self, t) }
+ fn visit_foreign_item(&mut self, i: &'ast ForeignItem) {
+ walk_foreign_item(self, i)
+ }
+ fn visit_global_asm(&mut self, ga: &'ast GlobalAsm) {
+ walk_global_asm(self, ga)
+ }
+ fn visit_item(&mut self, i: &'ast Item) {
+ walk_item(self, i)
+ }
+ fn visit_local(&mut self, l: &'ast Local) {
+ walk_local(self, l)
+ }
+ fn visit_block(&mut self, b: &'ast Block) {
+ walk_block(self, b)
+ }
+ fn visit_stmt(&mut self, s: &'ast Stmt) {
+ walk_stmt(self, s)
+ }
+ fn visit_param(&mut self, param: &'ast Param) {
+ walk_param(self, param)
+ }
+ fn visit_arm(&mut self, a: &'ast Arm) {
+ walk_arm(self, a)
+ }
+ fn visit_pat(&mut self, p: &'ast Pat) {
+ walk_pat(self, p)
+ }
+ fn visit_anon_const(&mut self, c: &'ast AnonConst) {
+ walk_anon_const(self, c)
+ }
+ fn visit_expr(&mut self, ex: &'ast Expr) {
+ walk_expr(self, ex)
+ }
+ fn visit_expr_post(&mut self, _ex: &'ast Expr) {}
+ fn visit_ty(&mut self, t: &'ast Ty) {
+ walk_ty(self, t)
+ }
fn visit_generic_param(&mut self, param: &'ast GenericParam) {
walk_generic_param(self, param)
}
- fn visit_generics(&mut self, g: &'ast Generics) { walk_generics(self, g) }
+ fn visit_generics(&mut self, g: &'ast Generics) {
+ walk_generics(self, g)
+ }
fn visit_where_predicate(&mut self, p: &'ast WherePredicate) {
walk_where_predicate(self, p)
}
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_ref(&mut self, t: &'ast TraitRef) { walk_trait_ref(self, t) }
+ fn visit_trait_item(&mut self, i: &'ast AssocItem) {
+ walk_trait_item(self, i)
+ }
+ fn visit_impl_item(&mut self, i: &'ast AssocItem) {
+ walk_impl_item(self, i)
+ }
+ fn visit_assoc_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)
}
fn visit_variant_data(&mut self, s: &'ast VariantData) {
walk_struct_def(self, s)
}
- fn visit_struct_field(&mut self, s: &'ast StructField) { walk_struct_field(self, s) }
- fn visit_enum_def(&mut self, enum_definition: &'ast EnumDef,
- generics: &'ast Generics, item_id: NodeId, _: Span) {
+ fn visit_struct_field(&mut self, s: &'ast StructField) {
+ walk_struct_field(self, s)
+ }
+ fn visit_enum_def(
+ &mut self,
+ enum_definition: &'ast EnumDef,
+ generics: &'ast Generics,
+ item_id: NodeId,
+ _: Span,
+ ) {
walk_enum_def(self, enum_definition, generics, item_id)
}
fn visit_variant(&mut self, v: &'ast Variant) {
visitor.visit_ident(lifetime.ident);
}
-pub fn walk_poly_trait_ref<'a, V>(visitor: &mut V,
- trait_ref: &'a PolyTraitRef,
- _: &TraitBoundModifier)
- where V: Visitor<'a>,
+pub fn walk_poly_trait_ref<'a, V>(
+ visitor: &mut V,
+ trait_ref: &'a PolyTraitRef,
+ _: &TraitBoundModifier,
+) where
+ V: Visitor<'a>,
{
walk_list!(visitor, visit_generic_param, &trait_ref.bound_generic_params);
visitor.visit_trait_ref(&trait_ref.trait_ref);
visitor.visit_name(item.span, orig_name);
}
}
- ItemKind::Use(ref use_tree) => {
- visitor.visit_use_tree(use_tree, item.id, false)
- }
- ItemKind::Static(ref typ, _, ref expr) |
- ItemKind::Const(ref typ, ref expr) => {
+ ItemKind::Use(ref use_tree) => visitor.visit_use_tree(use_tree, item.id, false),
+ ItemKind::Static(ref typ, _, ref expr) | ItemKind::Const(ref typ, ref expr) => {
visitor.visit_ty(typ);
visitor.visit_expr(expr);
}
ItemKind::Fn(ref sig, ref generics, ref body) => {
visitor.visit_generics(generics);
visitor.visit_fn_header(&sig.header);
- visitor.visit_fn(FnKind::ItemFn(item.ident, &sig.header, &item.vis, body),
- &sig.decl,
- item.span,
- item.id)
- }
- ItemKind::Mod(ref module) => {
- visitor.visit_mod(module, item.span, &item.attrs, item.id)
- }
+ visitor.visit_fn(
+ FnKind::ItemFn(item.ident, &sig.header, &item.vis, body),
+ &sig.decl,
+ item.span,
+ item.id,
+ )
+ }
+ ItemKind::Mod(ref module) => visitor.visit_mod(module, item.span, &item.attrs, item.id),
ItemKind::ForeignMod(ref foreign_module) => {
walk_list!(visitor, visit_foreign_item, &foreign_module.items);
}
visitor.visit_generics(generics);
visitor.visit_enum_def(enum_definition, generics, item.id, item.span)
}
- ItemKind::Impl(_, _, _,
- ref generics,
- ref opt_trait_reference,
- ref typ,
- ref impl_items) => {
+ ItemKind::Impl(_, _, _, ref generics, ref opt_trait_reference, ref typ, ref impl_items) => {
visitor.visit_generics(generics);
walk_list!(visitor, visit_trait_ref, opt_trait_reference);
visitor.visit_ty(typ);
walk_list!(visitor, visit_impl_item, impl_items);
}
- ItemKind::Struct(ref struct_definition, ref generics) |
- ItemKind::Union(ref struct_definition, ref generics) => {
+ ItemKind::Struct(ref struct_definition, ref generics)
+ | ItemKind::Union(ref struct_definition, ref generics) => {
visitor.visit_generics(generics);
visitor.visit_variant_data(struct_definition);
}
}
pub fn walk_variant<'a, V: Visitor<'a>>(visitor: &mut V, variant: &'a Variant)
- where V: Visitor<'a>,
+where
+ V: Visitor<'a>,
{
visitor.visit_ident(variant.ident);
visitor.visit_vis(&variant.vis);
pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {
match typ.kind {
- TyKind::Slice(ref ty) | TyKind::Paren(ref ty) => {
- visitor.visit_ty(ty)
- }
- TyKind::Ptr(ref mutable_type) => {
- visitor.visit_ty(&mutable_type.ty)
- }
+ TyKind::Slice(ref ty) | TyKind::Paren(ref ty) => visitor.visit_ty(ty),
+ TyKind::Ptr(ref mutable_type) => visitor.visit_ty(&mutable_type.ty),
TyKind::Rptr(ref opt_lifetime, ref mutable_type) => {
walk_list!(visitor, visit_lifetime, opt_lifetime);
visitor.visit_ty(&mutable_type.ty)
visitor.visit_ty(ty);
visitor.visit_anon_const(length)
}
- TyKind::TraitObject(ref bounds, ..) |
- TyKind::ImplTrait(_, ref bounds) => {
+ TyKind::TraitObject(ref bounds, ..) | TyKind::ImplTrait(_, ref bounds) => {
walk_list!(visitor, visit_param_bound, bounds);
}
- TyKind::Typeof(ref expression) => {
- visitor.visit_anon_const(expression)
- }
+ TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression),
TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => {}
- TyKind::Mac(ref mac) => {
- visitor.visit_mac(mac)
- }
- TyKind::Never |
- TyKind::CVarArgs => {}
+ TyKind::Mac(ref mac) => visitor.visit_mac(mac),
+ TyKind::Never | TyKind::CVarArgs => {}
}
}
}
}
-pub fn walk_use_tree<'a, V: Visitor<'a>>(
- visitor: &mut V, use_tree: &'a UseTree, id: NodeId,
-) {
+pub fn walk_use_tree<'a, V: Visitor<'a>>(visitor: &mut V, use_tree: &'a UseTree, id: NodeId) {
visitor.visit_path(&use_tree.prefix, id);
match use_tree.kind {
UseTreeKind::Simple(rename, ..) => {
visitor.visit_ident(rename);
}
}
- UseTreeKind::Glob => {},
+ UseTreeKind::Glob => {}
UseTreeKind::Nested(ref use_trees) => {
for &(ref nested_tree, nested_id) in use_trees {
visitor.visit_use_tree(nested_tree, nested_id, true);
}
}
-pub fn walk_path_segment<'a, V: Visitor<'a>>(visitor: &mut V,
- path_span: Span,
- segment: &'a PathSegment) {
+pub fn walk_path_segment<'a, V: Visitor<'a>>(
+ visitor: &mut V,
+ path_span: Span,
+ segment: &'a PathSegment,
+) {
visitor.visit_ident(segment.ident);
if let Some(ref args) = segment.args {
visitor.visit_generic_args(path_span, args);
}
}
-pub fn walk_generic_args<'a, V>(visitor: &mut V,
- _path_span: Span,
- generic_args: &'a GenericArgs)
- where V: Visitor<'a>,
+pub fn walk_generic_args<'a, V>(visitor: &mut V, _path_span: Span, generic_args: &'a GenericArgs)
+where
+ V: Visitor<'a>,
{
match *generic_args {
GenericArgs::AngleBracketed(ref data) => {
}
GenericArgs::Parenthesized(ref data) => {
walk_list!(visitor, visit_ty, &data.inputs);
- walk_list!(visitor, visit_ty, &data.output);
+ walk_fn_ret_ty(visitor, &data.output);
}
}
}
-pub fn walk_assoc_ty_constraint<'a, V: Visitor<'a>>(visitor: &mut V,
- constraint: &'a AssocTyConstraint) {
+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_path(path, pattern.id);
walk_list!(visitor, visit_field_pattern, fields);
}
- PatKind::Box(ref subpattern) |
- PatKind::Ref(ref subpattern, _) |
- PatKind::Paren(ref subpattern) => {
- visitor.visit_pat(subpattern)
- }
+ PatKind::Box(ref subpattern)
+ | PatKind::Ref(ref subpattern, _)
+ | PatKind::Paren(ref subpattern) => visitor.visit_pat(subpattern),
PatKind::Ident(_, ident, ref optional_subpattern) => {
visitor.visit_ident(ident);
walk_list!(visitor, visit_pat, optional_subpattern);
}
PatKind::Lit(ref expression) => visitor.visit_expr(expression),
PatKind::Range(ref lower_bound, ref upper_bound, _) => {
- visitor.visit_expr(lower_bound);
- visitor.visit_expr(upper_bound);
+ walk_list!(visitor, visit_expr, lower_bound);
+ walk_list!(visitor, visit_expr, upper_bound);
}
- PatKind::Wild | PatKind::Rest => {},
- PatKind::Tuple(ref elems)
- | PatKind::Slice(ref elems)
- | PatKind::Or(ref elems) => {
+ PatKind::Wild | PatKind::Rest => {}
+ PatKind::Tuple(ref elems) | PatKind::Slice(ref elems) | PatKind::Or(ref elems) => {
walk_list!(visitor, visit_pat, elems);
}
PatKind::Mac(ref mac) => visitor.visit_mac(mac),
pub fn walk_where_predicate<'a, V: Visitor<'a>>(visitor: &mut V, predicate: &'a WherePredicate) {
match *predicate {
- WherePredicate::BoundPredicate(WhereBoundPredicate{ref bounded_ty,
- ref bounds,
- ref bound_generic_params,
- ..}) => {
+ WherePredicate::BoundPredicate(WhereBoundPredicate {
+ ref bounded_ty,
+ ref bounds,
+ ref bound_generic_params,
+ ..
+ }) => {
visitor.visit_ty(bounded_ty);
walk_list!(visitor, visit_param_bound, bounds);
walk_list!(visitor, visit_generic_param, bound_generic_params);
}
- WherePredicate::RegionPredicate(WhereRegionPredicate{ref lifetime,
- ref bounds,
- ..}) => {
+ WherePredicate::RegionPredicate(WhereRegionPredicate {
+ ref lifetime, ref bounds, ..
+ }) => {
visitor.visit_lifetime(lifetime);
walk_list!(visitor, visit_param_bound, bounds);
}
- WherePredicate::EqPredicate(WhereEqPredicate{ref lhs_ty,
- ref rhs_ty,
- ..}) => {
+ WherePredicate::EqPredicate(WhereEqPredicate { ref lhs_ty, ref rhs_ty, .. }) => {
visitor.visit_ty(lhs_ty);
visitor.visit_ty(rhs_ty);
}
}
pub fn walk_fn<'a, V>(visitor: &mut V, kind: FnKind<'a>, declaration: &'a FnDecl, _span: Span)
- where V: Visitor<'a>,
+where
+ V: Visitor<'a>,
{
match kind {
FnKind::ItemFn(_, header, _, body) => {
}
}
-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) => {
+pub fn walk_impl_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) {
+ visitor.visit_assoc_item(item);
+}
+
+pub fn walk_trait_item<'a, V: Visitor<'a>>(visitor: &mut V, item: &'a AssocItem) {
+ visitor.visit_assoc_item(item);
+}
+
+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, default);
+ walk_list!(visitor, visit_expr, expr);
}
- TraitItemKind::Method(ref sig, None) => {
+ AssocItemKind::Fn(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, None, body),
- &sig.decl, trait_item.span, trait_item.id);
+ AssocItemKind::Fn(ref sig, Some(ref body)) => {
+ visitor.visit_fn(
+ FnKind::Method(item.ident, sig, &item.vis, body),
+ &sig.decl,
+ item.span,
+ item.id,
+ );
}
- TraitItemKind::Type(ref bounds, ref default) => {
+ AssocItemKind::TyAlias(ref bounds, ref ty) => {
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) => {
- visitor.visit_ty(ty);
- visitor.visit_expr(expr);
+ walk_list!(visitor, visit_ty, ty);
}
- ImplItemKind::Method(ref sig, ref body) => {
- visitor.visit_fn(FnKind::Method(impl_item.ident, sig, Some(&impl_item.vis), body),
- &sig.decl, impl_item.span, impl_item.id);
- }
- ImplItemKind::TyAlias(ref ty) => {
- visitor.visit_ty(ty);
- }
- ImplItemKind::Macro(ref mac) => {
+ AssocItemKind::Macro(ref mac) => {
visitor.visit_mac(mac);
}
}
walk_list!(visitor, visit_attribute, expression.attrs.iter());
match expression.kind {
- ExprKind::Box(ref subexpression) => {
- visitor.visit_expr(subexpression)
- }
+ ExprKind::Box(ref subexpression) => visitor.visit_expr(subexpression),
ExprKind::Array(ref subexpressions) => {
walk_list!(visitor, visit_expr, subexpressions);
}
visitor.visit_expr(subexpression);
walk_list!(visitor, visit_arm, arms);
}
- ExprKind::Closure(_, _, _, ref function_declaration, ref body, _decl_span) => {
- visitor.visit_fn(FnKind::Closure(body),
- function_declaration,
- expression.span,
- expression.id)
- }
+ ExprKind::Closure(_, _, _, ref function_declaration, ref body, _decl_span) => visitor
+ .visit_fn(FnKind::Closure(body), function_declaration, expression.span, expression.id),
ExprKind::Block(ref block, ref opt_label) => {
walk_list!(visitor, visit_label, opt_label);
visitor.visit_block(block);
visitor.visit_block(body);
}
ExprKind::Await(ref expr) => visitor.visit_expr(expr),
- ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
- visitor.visit_expr(left_hand_expression);
- visitor.visit_expr(right_hand_expression);
+ ExprKind::Assign(ref lhs, ref rhs, _) => {
+ visitor.visit_expr(lhs);
+ visitor.visit_expr(rhs);
}
ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(left_expression);
walk_list!(visitor, visit_expr, optional_expression);
}
ExprKind::Mac(ref mac) => visitor.visit_mac(mac),
- ExprKind::Paren(ref subexpression) => {
- visitor.visit_expr(subexpression)
- }
+ ExprKind::Paren(ref subexpression) => visitor.visit_expr(subexpression),
ExprKind::InlineAsm(ref ia) => {
for &(_, ref input) in &ia.inputs {
visitor.visit_expr(input)
ExprKind::Yield(ref optional_expression) => {
walk_list!(visitor, visit_expr, optional_expression);
}
- ExprKind::Try(ref subexpression) => {
- visitor.visit_expr(subexpression)
- }
- ExprKind::TryBlock(ref body) => {
- visitor.visit_block(body)
- }
+ ExprKind::Try(ref subexpression) => visitor.visit_expr(subexpression),
+ ExprKind::TryBlock(ref body) => visitor.visit_block(body),
ExprKind::Lit(_) | ExprKind::Err => {}
}
projects / rust.git / blobdiff