visit::FkItemFn(p.ident, p.generics, p.unsafety, p.constness, p.abi, p.vis)
};
let closure = |_: ClosureParts| {
- visit::FkFnBlock
+ visit::FkClosure
};
let method = |_, ident, sig: &'a ast::MethodSig, vis, _, _| {
visit::FkMethod(ident, sig, vis)
sp: Span,
fn_id: NodeId) {
match kind {
- visit::FkFnBlock => {}
+ visit::FkClosure => {}
_ => cx.param_env = ParameterEnvironment::for_item(cx.tcx, fn_id),
}
visit::walk_fn(self, fk, fd, b, s);
self.param_envs.pop();
}
- visit::FkFnBlock(..) => {
+ visit::FkClosure(..) => {
visit::walk_fn(self, fk, fd, b, s);
}
}
this.walk_fn(fk, fd, b, s)
})
}
- visit::FkFnBlock(..) => {
+ visit::FkClosure(..) => {
self.walk_fn(fk, fd, b, s)
}
}
self.visit_generics(&sig.generics);
self.visit_explicit_self(&sig.explicit_self);
}
- visit::FkFnBlock(..) => {
+ visit::FkClosure(..) => {
visit::walk_fn_decl(self, fd);
}
}
self.free_region_map = old_free_region_map;
}
- visit::FkFnBlock => {
+ visit::FkClosure => {
borrowck_fn(self, fk, fd, b, s, id);
}
}
cx.tcx.impl_or_trait_item(local_def(id)).as_opt_method()
}
// closures can't recur, so they don't matter.
- visit::FkFnBlock => return
+ visit::FkClosure => return
};
// Walk through this function (say `f`) looking to see if
self.visit_explicit_self(&sig.explicit_self);
MethodRibKind
}
- visit::FkFnBlock(..) => ClosureRibKind(node_id)
+ visit::FkClosure(..) => ClosureRibKind(node_id)
};
self.resolve_function(rib_kind, declaration, block);
}
fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
b: &'v ast::Block, span: Span, id: ast::NodeId) {
match fk {
- visit::FkFnBlock | visit::FkItemFn(..) => {}
+ visit::FkClosure | visit::FkItemFn(..) => {}
visit::FkMethod(..) => {
match self.tcx().impl_or_trait_item(local_def(id)) {
ty::ImplOrTraitItem::MethodTraitItem(ty_method) => {
visit::FkMethod(_, sig, _) => {
self.visit_generics_helper(&sig.generics)
}
- visit::FkFnBlock => {}
+ visit::FkClosure => {}
}
for argument in &function_declaration.inputs {
/// fn foo(&self)
FkMethod(Ident, &'a MethodSig, Option<Visibility>),
- /// Closures (|x, y| {})
- FkFnBlock,
+ /// |x, y| {}
+ FkClosure,
}
/// Each method of the Visitor trait is a hook to be potentially
visitor.visit_generics(&sig.generics);
visitor.visit_explicit_self(&sig.explicit_self);
}
- FkFnBlock(..) => {}
+ FkClosure(..) => {}
}
visitor.visit_block(function_body)
}
}
ExprClosure(_, ref function_declaration, ref body) => {
- visitor.visit_fn(FkFnBlock,
+ visitor.visit_fn(FkClosure,
&**function_declaration,
&**body,
expression.span,