use super::*;
#[cfg(not(feature = "full"))]
use constant;
pub trait Folder {
fn fold_ident(&mut self, _ident: Ident) -> Ident {
noop_fold_ident(self, _ident)
}
fn fold_derive_input(&mut self, derive_input: DeriveInput) -> DeriveInput {
noop_fold_derive_input(self, derive_input)
}
fn fold_ty(&mut self, ty: Ty) -> Ty {
noop_fold_ty(self, ty)
}
fn fold_generics(&mut self, generics: Generics) -> Generics {
noop_fold_generics(self, generics)
}
fn fold_ty_param_bound(&mut self, bound: TyParamBound) -> TyParamBound {
noop_fold_ty_param_bound(self, bound)
}
fn fold_poly_trait_ref(&mut self, trait_ref: PolyTraitRef) -> PolyTraitRef {
noop_fold_poly_trait_ref(self, trait_ref)
}
fn fold_variant_data(&mut self, data: VariantData) -> VariantData {
noop_fold_variant_data(self, data)
}
fn fold_field(&mut self, field: Field) -> Field {
noop_fold_field(self, field)
}
fn fold_variant(&mut self, variant: Variant) -> Variant {
noop_fold_variant(self, variant)
}
fn fold_lifetime(&mut self, _lifetime: Lifetime) -> Lifetime {
noop_fold_lifetime(self, _lifetime)
}
fn fold_lifetime_def(&mut self, lifetime: LifetimeDef) -> LifetimeDef {
noop_fold_lifetime_def(self, lifetime)
}
fn fold_path(&mut self, path: Path) -> Path {
noop_fold_path(self, path)
}
fn fold_path_segment(&mut self, path_segment: PathSegment) -> PathSegment {
noop_fold_path_segment(self, path_segment)
}
fn fold_path_parameters(&mut self, path_parameters: PathParameters) -> PathParameters {
noop_fold_path_parameters(self, path_parameters)
}
fn fold_assoc_type_binding(&mut self, type_binding: TypeBinding) -> TypeBinding {
noop_fold_assoc_type_binding(self, type_binding)
}
fn fold_attribute(&mut self, _attr: Attribute) -> Attribute {
noop_fold_attribute(self, _attr)
}
fn fold_fn_ret_ty(&mut self, ret_ty: FunctionRetTy) -> FunctionRetTy {
noop_fold_fn_ret_ty(self, ret_ty)
}
fn fold_const_expr(&mut self, expr: ConstExpr) -> ConstExpr {
noop_fold_const_expr(self, expr)
}
fn fold_lit(&mut self, _lit: Lit) -> Lit {
noop_fold_lit(self, _lit)
}
fn fold_mac(&mut self, mac: Mac) -> Mac {
noop_fold_mac(self, mac)
}
#[cfg(feature = "full")]
fn fold_crate(&mut self, _crate: Crate) -> Crate {
noop_fold_crate(self, _crate)
}
#[cfg(feature = "full")]
fn fold_item(&mut self, item: Item) -> Item {
noop_fold_item(self, item)
}
#[cfg(feature = "full")]
fn fold_expr(&mut self, expr: Expr) -> Expr {
noop_fold_expr(self, expr)
}
#[cfg(feature = "full")]
fn fold_foreign_item(&mut self, foreign_item: ForeignItem) -> ForeignItem {
noop_fold_foreign_item(self, foreign_item)
}
#[cfg(feature = "full")]
fn fold_pat(&mut self, pat: Pat) -> Pat {
noop_fold_pat(self, pat)
}
#[cfg(feature = "full")]
fn fold_fn_decl(&mut self, fn_decl: FnDecl) -> FnDecl {
noop_fold_fn_decl(self, fn_decl)
}
#[cfg(feature = "full")]
fn fold_trait_item(&mut self, trait_item: TraitItem) -> TraitItem {
noop_fold_trait_item(self, trait_item)
}
#[cfg(feature = "full")]
fn fold_impl_item(&mut self, impl_item: ImplItem) -> ImplItem {
noop_fold_impl_item(self, impl_item)
}
#[cfg(feature = "full")]
fn fold_method_sig(&mut self, method_sig: MethodSig) -> MethodSig {
noop_fold_method_sig(self, method_sig)
}
#[cfg(feature = "full")]
fn fold_stmt(&mut self, stmt: Stmt) -> Stmt {
noop_fold_stmt(self, stmt)
}
#[cfg(feature = "full")]
fn fold_block(&mut self, block: Block) -> Block {
noop_fold_block(self, block)
}
#[cfg(feature = "full")]
fn fold_local(&mut self, local: Local) -> Local {
noop_fold_local(self, local)
}
#[cfg(feature = "full")]
fn fold_view_path(&mut self, view_path: ViewPath) -> ViewPath {
noop_fold_view_path(self, view_path)
}
}
trait LiftOnce<T, U> {
type Output;
fn lift<F>(self, f: F) -> Self::Output where F: FnOnce(T) -> U;
}
impl<T, U> LiftOnce<T, U> for Box<T> {
type Output = Box<U>;
#[cfg_attr(feature = "cargo-clippy", allow(boxed_local))]
fn lift<F>(self, f: F) -> Box<U>
where F: FnOnce(T) -> U
{
Box::new(f(*self))
}
}
trait LiftMut<T, U> {
type Output;
fn lift<F>(self, f: F) -> Self::Output where F: FnMut(T) -> U;
}
impl<T, U> LiftMut<T, U> for Vec<T> {
type Output = Vec<U>;
fn lift<F>(self, f: F) -> Vec<U>
where F: FnMut(T) -> U
{
self.into_iter().map(f).collect()
}
}
pub fn noop_fold_ident<F: ?Sized + Folder>(_: &mut F, _ident: Ident) -> Ident {
_ident
}
pub fn noop_fold_derive_input<F: ?Sized + Folder>(folder: &mut F,
DeriveInput{ ident,
vis,
attrs,
generics,
body }: DeriveInput) -> DeriveInput{
use Body::*;
DeriveInput {
ident: folder.fold_ident(ident),
vis: noop_fold_vis(folder, vis),
attrs: attrs.lift(|a| folder.fold_attribute(a)),
generics: folder.fold_generics(generics),
body: match body {
Enum(variants) => Enum(variants.lift(move |v| folder.fold_variant(v))),
Struct(variant_data) => Struct(folder.fold_variant_data(variant_data)),
},
}
}
pub fn noop_fold_ty<F: ?Sized + Folder>(folder: &mut F, ty: Ty) -> Ty {
use Ty::*;
match ty {
Slice(inner) => Slice(inner.lift(|v| folder.fold_ty(v))),
Paren(inner) => Paren(inner.lift(|v| folder.fold_ty(v))),
Ptr(mutable_type) => {
let mutable_type_ = *mutable_type;
let MutTy { ty, mutability }: MutTy = mutable_type_;
Ptr(Box::new(MutTy {
ty: folder.fold_ty(ty),
mutability: mutability,
}))
}
Rptr(opt_lifetime, mutable_type) => {
let mutable_type_ = *mutable_type;
let MutTy { ty, mutability }: MutTy = mutable_type_;
Rptr(opt_lifetime.map(|l| folder.fold_lifetime(l)),
Box::new(MutTy {
ty: folder.fold_ty(ty),
mutability: mutability,
}))
}
Never => Never,
Infer => Infer,
Tup(tuple_element_types) => Tup(tuple_element_types.lift(|x| folder.fold_ty(x))),
BareFn(bare_fn) => {
let bf_ = *bare_fn;
let BareFnTy { unsafety, abi, lifetimes, inputs, output, variadic } = bf_;
BareFn(Box::new(BareFnTy {
unsafety: unsafety,
abi: abi,
lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
inputs: inputs.lift(|v| {
BareFnArg {
name: v.name.map(|n| folder.fold_ident(n)),
ty: folder.fold_ty(v.ty),
}
}),
output: folder.fold_fn_ret_ty(output),
variadic: variadic,
}))
}
Path(maybe_qself, path) => {
Path(maybe_qself.map(|v| noop_fold_qself(folder, v)),
folder.fold_path(path))
}
Array(inner, len) => {
Array({
inner.lift(|v| folder.fold_ty(v))
},
folder.fold_const_expr(len))
}
TraitObject(bounds) => TraitObject(bounds.lift(|v| folder.fold_ty_param_bound(v))),
ImplTrait(bounds) => ImplTrait(bounds.lift(|v| folder.fold_ty_param_bound(v))),
Mac(mac) => Mac(folder.fold_mac(mac)),
}
}
fn noop_fold_qself<F: ?Sized + Folder>(folder: &mut F, QSelf { ty, position }: QSelf) -> QSelf {
QSelf {
ty: Box::new(folder.fold_ty(*(ty))),
position: position,
}
}
pub fn noop_fold_generics<F: ?Sized + Folder>(folder: &mut F,
Generics { lifetimes, ty_params, where_clause }: Generics)
-> Generics{
use WherePredicate::*;
Generics {
lifetimes: lifetimes.lift(|l| folder.fold_lifetime_def(l)),
ty_params: ty_params.lift(|ty| {
TyParam {
attrs: ty.attrs.lift(|a| folder.fold_attribute(a)),
ident: folder.fold_ident(ty.ident),
bounds: ty.bounds.lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
default: ty.default.map(|v| folder.fold_ty(v)),
}
}),
where_clause: WhereClause {
predicates: where_clause.predicates.lift(|p| match p {
BoundPredicate(bound_predicate) => {
BoundPredicate(WhereBoundPredicate {
bound_lifetimes: bound_predicate.bound_lifetimes
.lift(|l| folder.fold_lifetime_def(l)),
bounded_ty: folder.fold_ty(bound_predicate.bounded_ty),
bounds: bound_predicate.bounds
.lift(|ty_pb| folder.fold_ty_param_bound(ty_pb)),
})
}
RegionPredicate(region_predicate) => {
RegionPredicate(WhereRegionPredicate {
lifetime: folder.fold_lifetime(region_predicate.lifetime),
bounds: region_predicate.bounds
.lift(|b| folder.fold_lifetime(b)),
})
}
EqPredicate(eq_predicate) => {
EqPredicate(WhereEqPredicate {
lhs_ty: folder.fold_ty(eq_predicate.lhs_ty),
rhs_ty: folder.fold_ty(eq_predicate.rhs_ty),
})
}
}),
},
}
}
pub fn noop_fold_ty_param_bound<F: ?Sized + Folder>(folder: &mut F,
bound: TyParamBound)
-> TyParamBound {
use TyParamBound::*;
match bound {
Trait(ty, modifier) => Trait(folder.fold_poly_trait_ref(ty), modifier),
Region(lifetime) => Region(folder.fold_lifetime(lifetime)),
}
}
pub fn noop_fold_poly_trait_ref<F: ?Sized + Folder>(folder: &mut F,
trait_ref: PolyTraitRef)
-> PolyTraitRef {
PolyTraitRef {
bound_lifetimes: trait_ref.bound_lifetimes.lift(|bl| folder.fold_lifetime_def(bl)),
trait_ref: folder.fold_path(trait_ref.trait_ref),
}
}
pub fn noop_fold_variant_data<F: ?Sized + Folder>(folder: &mut F,
data: VariantData)
-> VariantData {
use VariantData::*;
match data {
Struct(fields) => Struct(fields.lift(|f| folder.fold_field(f))),
Tuple(fields) => Tuple(fields.lift(|f| folder.fold_field(f))),
Unit => Unit,
}
}
pub fn noop_fold_field<F: ?Sized + Folder>(folder: &mut F, field: Field) -> Field {
Field {
ident: field.ident.map(|i| folder.fold_ident(i)),
vis: noop_fold_vis(folder, field.vis),
attrs: field.attrs.lift(|a| folder.fold_attribute(a)),
ty: folder.fold_ty(field.ty),
}
}
pub fn noop_fold_variant<F: ?Sized + Folder>(folder: &mut F,
Variant { ident, attrs, data, discriminant }: Variant)
-> Variant{
Variant {
ident: folder.fold_ident(ident),
attrs: attrs.lift(|v| folder.fold_attribute(v)),
data: folder.fold_variant_data(data),
discriminant: discriminant.map(|ce| folder.fold_const_expr(ce)),
}
}
pub fn noop_fold_lifetime<F: ?Sized + Folder>(folder: &mut F, _lifetime: Lifetime) -> Lifetime {
Lifetime { ident: folder.fold_ident(_lifetime.ident) }
}
pub fn noop_fold_lifetime_def<F: ?Sized + Folder>(folder: &mut F,
LifetimeDef { attrs, lifetime, bounds }: LifetimeDef)
-> LifetimeDef{
LifetimeDef {
attrs: attrs.lift(|x| folder.fold_attribute(x)),
lifetime: folder.fold_lifetime(lifetime),
bounds: bounds.lift(|l| folder.fold_lifetime(l)),
}
}
pub fn noop_fold_path<F: ?Sized + Folder>(folder: &mut F, Path { global, segments }: Path) -> Path {
Path {
global: global,
segments: segments.lift(|s| folder.fold_path_segment(s)),
}
}
pub fn noop_fold_path_segment<F: ?Sized + Folder>(folder: &mut F,
PathSegment { ident, parameters }: PathSegment)
-> PathSegment {
PathSegment {
ident: folder.fold_ident(ident),
parameters: folder.fold_path_parameters(parameters),
}
}
pub fn noop_fold_path_parameters<F: ?Sized + Folder>(folder: &mut F,
path_parameters: PathParameters)
-> PathParameters {
use PathParameters::*;
match path_parameters {
AngleBracketed(d) => {
let AngleBracketedParameterData { lifetimes, types, bindings } = d;
AngleBracketed(AngleBracketedParameterData {
lifetimes: lifetimes.into_iter()
.map(|l| folder.fold_lifetime(l))
.collect(),
types: types.lift(|ty| folder.fold_ty(ty)),
bindings: bindings.lift(|tb| folder.fold_assoc_type_binding(tb)),
})
}
Parenthesized(d) => {
let ParenthesizedParameterData { inputs, output } = d;
Parenthesized(ParenthesizedParameterData {
inputs: inputs.lift(|i| folder.fold_ty(i)),
output: output.map(|v| folder.fold_ty(v)),
})
}
}
}
pub fn noop_fold_assoc_type_binding<F: ?Sized + Folder>(folder: &mut F,
TypeBinding { ident, ty }: TypeBinding)
-> TypeBinding {
TypeBinding {
ident: folder.fold_ident(ident),
ty: folder.fold_ty(ty),
}
}
pub fn noop_fold_attribute<F: ?Sized + Folder>(_: &mut F, _attr: Attribute) -> Attribute {
_attr
}
pub fn noop_fold_fn_ret_ty<F: ?Sized + Folder>(folder: &mut F,
ret_ty: FunctionRetTy)
-> FunctionRetTy {
use FunctionRetTy::*;
match ret_ty {
Default => Default,
Ty(ty) => Ty(folder.fold_ty(ty)),
}
}
pub fn noop_fold_const_expr<F: ?Sized + Folder>(folder: &mut F, expr: ConstExpr) -> ConstExpr {
use ConstExpr::*;
match expr {
Call(f, args) => {
Call(f.lift(|e| folder.fold_const_expr(e)),
args.lift(|v| folder.fold_const_expr(v)))
}
Binary(op, lhs, rhs) => {
Binary(op,
lhs.lift(|e| folder.fold_const_expr(e)),
rhs.lift(|e| folder.fold_const_expr(e)))
}
Unary(op, e) => Unary(op, e.lift(|e| folder.fold_const_expr(e))),
Lit(l) => Lit(folder.fold_lit(l)),
Cast(e, ty) => {
Cast(e.lift(|e| folder.fold_const_expr(e)),
ty.lift(|v| folder.fold_ty(v)))
}
Path(p) => Path(folder.fold_path(p)),
Index(o, i) => {
Index(o.lift(|e| folder.fold_const_expr(e)),
i.lift(|e| folder.fold_const_expr(e)))
}
Paren(no_op) => Paren(no_op.lift(|e| folder.fold_const_expr(e))),
Other(e) => Other(noop_fold_other_const_expr(folder, e)),
}
}
#[cfg(feature = "full")]
fn noop_fold_other_const_expr<F: ?Sized + Folder>(folder: &mut F, e: Expr) -> Expr {
folder.fold_expr(e)
}
#[cfg(not(feature = "full"))]
fn noop_fold_other_const_expr<F: ?Sized + Folder>(_: &mut F,
e: constant::Other)
-> constant::Other {
e
}
pub fn noop_fold_lit<F: ?Sized + Folder>(_: &mut F, _lit: Lit) -> Lit {
_lit
}
pub fn noop_fold_tt<F: ?Sized + Folder>(folder: &mut F, tt: TokenTree) -> TokenTree {
use TokenTree::*;
use Token::*;
match tt {
Token(token) => {
Token(match token {
Literal(lit) => Literal(folder.fold_lit(lit)),
Ident(ident) => Ident(folder.fold_ident(ident)),
Lifetime(ident) => Lifetime(folder.fold_ident(ident)),
x => x,
})
}
Delimited(super::Delimited { delim, tts }) => {
Delimited(super::Delimited {
delim: delim,
tts: tts.lift(|v| noop_fold_tt(folder, v)),
})
}
}
}
pub fn noop_fold_mac<F: ?Sized + Folder>(folder: &mut F, Mac { path, tts }: Mac) -> Mac {
Mac {
path: folder.fold_path(path),
tts: tts.lift(|tt| noop_fold_tt(folder, tt)),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_crate<F: ?Sized + Folder>(folder: &mut F,
Crate { shebang, attrs, items }: Crate)
-> Crate {
Crate {
shebang: shebang,
attrs: attrs.lift(|a| folder.fold_attribute(a)),
items: items.lift(|i| folder.fold_item(i)),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_block<F: ?Sized + Folder>(folder: &mut F, block: Block) -> Block {
Block { stmts: block.stmts.lift(|s| folder.fold_stmt(s)) }
}
fn noop_fold_vis<F: ?Sized + Folder>(folder: &mut F, vis: Visibility) -> Visibility {
use Visibility::*;
match vis {
Crate => Crate,
Inherited => Inherited,
Public => Public,
Restricted(path) => Restricted(path.lift(|p| folder.fold_path(p))),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_item<F: ?Sized + Folder>(folder: &mut F,
Item { ident, vis, attrs, node }: Item)
-> Item {
use ItemKind::*;
Item {
ident: folder.fold_ident(ident.clone()),
vis: noop_fold_vis(folder, vis),
attrs: attrs.lift(|a| folder.fold_attribute(a)),
node: match node {
ExternCrate(name) => ExternCrate(name.map(|i| folder.fold_ident(i))),
Use(view_path) => Use(Box::new(folder.fold_view_path(*view_path))),
Static(ty, mutability, expr) => {
Static(Box::new(folder.fold_ty(*ty)),
mutability,
expr.lift(|e| folder.fold_expr(e)))
}
Const(ty, expr) => {
Const(ty.lift(|ty| folder.fold_ty(ty)),
expr.lift(|e| folder.fold_expr(e)))
}
Fn(fn_decl, unsafety, constness, abi, generics, block) => {
Fn(fn_decl.lift(|v| folder.fold_fn_decl(v)),
unsafety,
constness,
abi,
folder.fold_generics(generics),
block.lift(|v| folder.fold_block(v)))
}
Mod(items) => Mod(items.map(|items| items.lift(|i| folder.fold_item(i)))),
ForeignMod(super::ForeignMod { abi, items }) => {
ForeignMod(super::ForeignMod {
abi: abi,
items: items.lift(|foreign_item| {
folder.fold_foreign_item(foreign_item)
}),
})
}
Ty(ty, generics) => {
Ty(ty.lift(|ty| folder.fold_ty(ty)),
folder.fold_generics(generics))
}
Enum(variants, generics) => {
Enum(variants.lift(|v| folder.fold_variant(v)),
folder.fold_generics(generics))
}
Struct(variant_data, generics) => {
Struct(folder.fold_variant_data(variant_data),
folder.fold_generics(generics))
}
Union(variant_data, generics) => {
Union(folder.fold_variant_data(variant_data),
folder.fold_generics(generics))
}
Trait(unsafety, generics, typbs, trait_items) => {
Trait(unsafety,
folder.fold_generics(generics),
typbs.lift(|typb| folder.fold_ty_param_bound(typb)),
trait_items.lift(|ti| folder.fold_trait_item(ti)))
}
DefaultImpl(unsafety, path) => DefaultImpl(unsafety, folder.fold_path(path)),
Impl(unsafety, impl_polarity, generics, path, ty, impl_items) => {
Impl(unsafety,
impl_polarity,
folder.fold_generics(generics),
path.map(|p| folder.fold_path(p)),
ty.lift(|ty| folder.fold_ty(ty)),
impl_items.lift(|i| folder.fold_impl_item(i)))
}
Mac(mac) => Mac(folder.fold_mac(mac)),
},
}
}
#[cfg(feature = "full")]
pub fn noop_fold_expr<F: ?Sized + Folder>(folder: &mut F, Expr { node, attrs }: Expr) -> Expr {
use ExprKind::*;
Expr {
node: match node {
ExprKind::Box(e) => ExprKind::Box(e.lift(|e| folder.fold_expr(e))),
InPlace(place, value) => {
InPlace(place.lift(|e| folder.fold_expr(e)),
value.lift(|e| folder.fold_expr(e)))
}
Array(array) => Array(array.lift(|e| folder.fold_expr(e))),
Call(function, args) => {
Call(function.lift(|e| folder.fold_expr(e)),
args.lift(|e| folder.fold_expr(e)))
}
MethodCall(method, tys, args) => {
MethodCall(folder.fold_ident(method),
tys.lift(|t| folder.fold_ty(t)),
args.lift(|e| folder.fold_expr(e)))
}
Tup(args) => Tup(args.lift(|e| folder.fold_expr(e))),
Binary(bop, lhs, rhs) => {
Binary(bop,
lhs.lift(|e| folder.fold_expr(e)),
rhs.lift(|e| folder.fold_expr(e)))
}
Unary(uop, e) => Unary(uop, e.lift(|e| folder.fold_expr(e))),
Lit(lit) => Lit(folder.fold_lit(lit)),
Cast(e, ty) => {
Cast(e.lift(|e| folder.fold_expr(e)),
ty.lift(|t| folder.fold_ty(t)))
}
Type(e, ty) => {
Type(e.lift(|e| folder.fold_expr(e)),
ty.lift(|t| folder.fold_ty(t)))
}
If(e, if_block, else_block) => {
If(e.lift(|e| folder.fold_expr(e)),
folder.fold_block(if_block),
else_block.map(|v| v.lift(|e| folder.fold_expr(e))))
}
IfLet(pat, expr, block, else_block) => {
IfLet(pat.lift(|p| folder.fold_pat(p)),
expr.lift(|e| folder.fold_expr(e)),
folder.fold_block(block),
else_block.map(|v| v.lift(|e| folder.fold_expr(e))))
}
While(e, block, label) => {
While(e.lift(|e| folder.fold_expr(e)),
folder.fold_block(block),
label.map(|i| folder.fold_ident(i)))
}
WhileLet(pat, expr, block, label) => {
WhileLet(pat.lift(|p| folder.fold_pat(p)),
expr.lift(|e| folder.fold_expr(e)),
folder.fold_block(block),
label.map(|i| folder.fold_ident(i)))
}
ForLoop(pat, expr, block, label) => {
ForLoop(pat.lift(|p| folder.fold_pat(p)),
expr.lift(|e| folder.fold_expr(e)),
folder.fold_block(block),
label.map(|i| folder.fold_ident(i)))
}
Loop(block, label) => {
Loop(folder.fold_block(block),
label.map(|i| folder.fold_ident(i)))
}
Match(e, arms) => {
Match(e.lift(|e| folder.fold_expr(e)),
arms.lift(|Arm { attrs, pats, guard, body }: Arm| {
Arm {
attrs: attrs.lift(|a| folder.fold_attribute(a)),
pats: pats.lift(|p| folder.fold_pat(p)),
guard: guard.map(|v| v.lift(|e| folder.fold_expr(e))),
body: body.lift(|e| folder.fold_expr(e)),
}
}))
}
Closure(capture_by, fn_decl, expr) => {
Closure(capture_by,
fn_decl.lift(|v| folder.fold_fn_decl(v)),
expr.lift(|e| folder.fold_expr(e)))
}
Block(unsafety, block) => Block(unsafety, folder.fold_block(block)),
Assign(lhs, rhs) => {
Assign(lhs.lift(|e| folder.fold_expr(e)),
rhs.lift(|e| folder.fold_expr(e)))
}
AssignOp(bop, lhs, rhs) => {
AssignOp(bop,
lhs.lift(|e| folder.fold_expr(e)),
rhs.lift(|e| folder.fold_expr(e)))
}
Field(expr, name) => Field(expr.lift(|e| folder.fold_expr(e)), folder.fold_ident(name)),
TupField(expr, index) => TupField(expr.lift(|e| folder.fold_expr(e)), index),
Index(expr, index) => {
Index(expr.lift(|e| folder.fold_expr(e)),
index.lift(|e| folder.fold_expr(e)))
}
Range(lhs, rhs, limits) => {
Range(lhs.map(|v| v.lift(|e| folder.fold_expr(e))),
rhs.map(|v| v.lift(|e| folder.fold_expr(e))),
limits)
}
Path(qself, path) => {
Path(qself.map(|v| noop_fold_qself(folder, v)),
folder.fold_path(path))
}
AddrOf(mutability, expr) => AddrOf(mutability, expr.lift(|e| folder.fold_expr(e))),
Break(label, expr) => {
Break(label.map(|i| folder.fold_ident(i)),
expr.map(|v| v.lift(|e| folder.fold_expr(e))))
}
Continue(label) => Continue(label.map(|i| folder.fold_ident(i))),
Ret(expr) => Ret(expr.map(|v| v.lift(|e| folder.fold_expr(e)))),
ExprKind::Mac(mac) => ExprKind::Mac(folder.fold_mac(mac)),
Struct(path, fields, expr) => {
Struct(folder.fold_path(path),
fields.lift(|FieldValue { ident, expr, is_shorthand, attrs }: FieldValue| {
FieldValue {
ident: folder.fold_ident(ident),
expr: folder.fold_expr(expr),
is_shorthand: is_shorthand,
attrs: attrs.lift(|v| folder.fold_attribute(v)),
}
}),
expr.map(|v| v.lift(|e| folder.fold_expr(e))))
}
Repeat(element, number) => {
Repeat(element.lift(|e| folder.fold_expr(e)),
number.lift(|e| folder.fold_expr(e)))
}
Paren(expr) => Paren(expr.lift(|e| folder.fold_expr(e))),
Try(expr) => Try(expr.lift(|e| folder.fold_expr(e))),
},
attrs: attrs.into_iter().map(|a| folder.fold_attribute(a)).collect(),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_foreign_item<F: ?Sized + Folder>(folder: &mut F,
ForeignItem { ident, attrs, node, vis }: ForeignItem)
-> ForeignItem{
ForeignItem {
ident: folder.fold_ident(ident),
attrs: attrs.into_iter().map(|a| folder.fold_attribute(a)).collect(),
node: match node {
ForeignItemKind::Fn(fn_dcl, generics) => {
ForeignItemKind::Fn(fn_dcl.lift(|v| folder.fold_fn_decl(v)),
folder.fold_generics(generics))
}
ForeignItemKind::Static(ty, mutability) => {
ForeignItemKind::Static(ty.lift(|v| folder.fold_ty(v)), mutability)
}
},
vis: noop_fold_vis(folder, vis),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_pat<F: ?Sized + Folder>(folder: &mut F, pat: Pat) -> Pat {
use Pat::*;
match pat {
Wild => Wild,
Ident(binding_mode, ident, pat) => {
Ident(binding_mode,
folder.fold_ident(ident),
pat.map(|p| p.lift(|p| folder.fold_pat(p))))
}
Struct(path, field_patterns, dots) => {
Struct(folder.fold_path(path),
field_patterns.lift(|FieldPat { ident, pat, is_shorthand, attrs }: FieldPat| {
FieldPat {
ident: folder.fold_ident(ident),
pat: pat.lift(|p| folder.fold_pat(p)),
is_shorthand: is_shorthand,
attrs: attrs.lift(|a| folder.fold_attribute(a)),
}
}),
dots)
}
TupleStruct(path, pats, len) => {
TupleStruct(folder.fold_path(path),
pats.lift(|p| folder.fold_pat(p)),
len)
}
Path(qself, path) => {
Path(qself.map(|v| noop_fold_qself(folder, v)),
folder.fold_path(path))
}
Tuple(pats, len) => Tuple(pats.lift(|p| folder.fold_pat(p)), len),
Box(b) => Box(b.lift(|p| folder.fold_pat(p))),
Ref(b, mutability) => Ref(b.lift(|p| folder.fold_pat(p)), mutability),
Lit(expr) => Lit(expr.lift(|e| folder.fold_expr(e))),
Range(l, r) => {
Range(l.lift(|e| folder.fold_expr(e)),
r.lift(|e| folder.fold_expr(e)))
}
Slice(lefts, pat, rights) => {
Slice(lefts.lift(|p| folder.fold_pat(p)),
pat.map(|v| v.lift(|p| folder.fold_pat(p))),
rights.lift(|p| folder.fold_pat(p)))
}
Mac(mac) => Mac(folder.fold_mac(mac)),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_fn_decl<F: ?Sized + Folder>(folder: &mut F,
FnDecl { inputs, output, variadic }: FnDecl)
-> FnDecl {
FnDecl {
inputs: inputs.lift(|a| {
use FnArg::*;
match a {
SelfRef(lifetime, mutability) => {
SelfRef(lifetime.map(|v| folder.fold_lifetime(v)), mutability)
}
SelfValue(mutability) => SelfValue(mutability),
Captured(pat, ty) => Captured(folder.fold_pat(pat), folder.fold_ty(ty)),
Ignored(ty) => Ignored(folder.fold_ty(ty)),
}
}),
output: folder.fold_fn_ret_ty(output),
variadic: variadic,
}
}
#[cfg(feature = "full")]
pub fn noop_fold_trait_item<F: ?Sized + Folder>(folder: &mut F,
TraitItem { ident, attrs, node }: TraitItem)
-> TraitItem {
use TraitItemKind::*;
TraitItem {
ident: folder.fold_ident(ident),
attrs: attrs.lift(|v| folder.fold_attribute(v)),
node: match node {
Const(ty, expr) => Const(folder.fold_ty(ty), expr.map(|v| folder.fold_expr(v))),
Method(sig, block) => {
Method(folder.fold_method_sig(sig),
block.map(|v| folder.fold_block(v)))
}
Type(ty_pbs, ty) => {
Type(ty_pbs.lift(|v| folder.fold_ty_param_bound(v)),
ty.map(|v| folder.fold_ty(v)))
}
Macro(mac) => Macro(folder.fold_mac(mac)),
},
}
}
#[cfg(feature = "full")]
pub fn noop_fold_impl_item<F: ?Sized + Folder>(folder: &mut F,
ImplItem { ident, vis, defaultness, attrs, node }: ImplItem)
-> ImplItem{
use ImplItemKind::*;
ImplItem {
ident: folder.fold_ident(ident),
vis: noop_fold_vis(folder, vis),
defaultness: defaultness,
attrs: attrs.lift(|v| folder.fold_attribute(v)),
node: match node {
Const(ty, expr) => Const(folder.fold_ty(ty), folder.fold_expr(expr)),
Method(sig, block) => Method(folder.fold_method_sig(sig), folder.fold_block(block)),
Type(ty) => Type(folder.fold_ty(ty)),
Macro(mac) => Macro(folder.fold_mac(mac)),
},
}
}
#[cfg(feature = "full")]
pub fn noop_fold_method_sig<F: ?Sized + Folder>(folder: &mut F, MethodSig{unsafety, constness, abi, decl, generics}:MethodSig) -> MethodSig{
MethodSig {
unsafety: unsafety,
constness: constness,
abi: abi,
decl: folder.fold_fn_decl(decl),
generics: folder.fold_generics(generics),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_stmt<F: ?Sized + Folder>(folder: &mut F, stmt: Stmt) -> Stmt {
use Stmt::*;
match stmt {
Local(local) => Local(local.lift(|l| folder.fold_local(l))),
Item(item) => Item(item.lift(|v| folder.fold_item(v))),
Expr(expr) => Expr(expr.lift(|v| folder.fold_expr(v))),
Semi(expr) => Semi(expr.lift(|v| folder.fold_expr(v))),
Mac(mac_stmt) => {
Mac(mac_stmt.lift(|(mac, style, attrs)| {
(folder.fold_mac(mac),
style,
attrs.lift(|a| folder.fold_attribute(a)))
}))
}
}
}
#[cfg(feature = "full")]
pub fn noop_fold_local<F: ?Sized + Folder>(folder: &mut F,
Local { pat, ty, init, attrs }: Local)
-> Local {
Local {
pat: pat.lift(|v| folder.fold_pat(v)),
ty: ty.map(|v| v.lift(|t| folder.fold_ty(t))),
init: init.map(|v| v.lift(|e| folder.fold_expr(e))),
attrs: attrs.lift(|a| folder.fold_attribute(a)),
}
}
#[cfg(feature = "full")]
pub fn noop_fold_view_path<F: ?Sized + Folder>(folder: &mut F, view_path: ViewPath) -> ViewPath {
use ViewPath::*;
match view_path {
Simple(path, ident) => Simple(folder.fold_path(path), ident.map(|i| folder.fold_ident(i))),
Glob(path) => Glob(folder.fold_path(path)),
List(path, items) => {
List(folder.fold_path(path),
items.lift(|PathListItem { name, rename }: PathListItem| {
PathListItem {
name: folder.fold_ident(name),
rename: rename.map(|i| folder.fold_ident(i)),
}
}))
}
}
}