bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

libsyntax: Remove fn@, fn~, and fn& from libsyntax. rs=defun

Browse source
This commit is contained in:
Patrick Walton 2013-03-01 13:30:06 -08:00
parent 97fd421319
commit 256afb8a10
9 changed files with 181 additions and 194 deletions
Download patch file Download diff file Expand all files Collapse all files

75
src/libsyntax/ast_util.rs
View file

@ -396,8 +396,8 @@ pub fn empty(range: id_range) -> bool {
range.min >= range.max
}
pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
let visit_generics = fn@(generics: &Generics) {
pub fn id_visitor(vfn: @fn(node_id)) -> visit::vt<()> {
let visit_generics: @fn(&Generics) = |generics| {
for generics.ty_params.each |p| {
vfn(p.id);
}
@ -408,7 +408,7 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
visit::mk_simple_visitor(@visit::SimpleVisitor {
visit_mod: |_m, _sp, id| vfn(id),
visit_view_item: fn@(vi: @view_item) {
visit_view_item: |vi| {
match vi.node {
view_item_extern_mod(_, _, id) => vfn(id),
view_item_use(ref vps) => {
@ -423,11 +423,9 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
}
},
visit_foreign_item: fn@(ni: @foreign_item) {
vfn(ni.id)
},
visit_foreign_item: |ni| vfn(ni.id),
visit_item: fn@(i: @item) {
visit_item: |i| {
vfn(i.id);
match i.node {
item_enum(ref enum_definition, _) =>
@ -436,36 +434,21 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
}
},
visit_local: fn@(l: @local) {
vfn(l.node.id);
},
visit_local: |l| vfn(l.node.id),
visit_block: |b| vfn(b.node.id),
visit_stmt: |s| vfn(ast_util::stmt_id(*s)),
visit_arm: |_| {},
visit_pat: |p| vfn(p.id),
visit_decl: |_| {},
visit_block: fn@(b: &blk) {
vfn(b.node.id);
},
visit_stmt: fn@(s: @stmt) {
vfn(ast_util::stmt_id(*s));
},
visit_arm: fn@(_a: &arm) { },
visit_pat: fn@(p: @pat) {
vfn(p.id)
},
visit_decl: fn@(_d: @decl) {
},
visit_expr: fn@(e: @expr) {
visit_expr: |e| {
vfn(e.callee_id);
vfn(e.id);
},
visit_expr_post: fn@(_e: @expr) {
},
visit_expr_post: |_| {},
visit_ty: fn@(t: @Ty) {
visit_ty: |t| {
match t.node {
ty_path(_, id) => vfn(id),
_ => { /* fall through */ }
@ -474,8 +457,7 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
visit_generics: visit_generics,
visit_fn: fn@(fk: &visit::fn_kind, d: &ast::fn_decl,
_b: &ast::blk, _sp: span, id: ast::node_id) {
visit_fn: |fk, d, _, _, id| {
vfn(id);
match *fk {
@ -502,32 +484,19 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
}
},
visit_ty_method: fn@(_ty_m: &ty_method) {
},
visit_trait_method: fn@(_ty_m: &trait_method) {
},
visit_struct_def: fn@(_sd: @struct_def,
_id: ident,
_generics: &Generics,
_id: node_id) {
},
visit_struct_field: fn@(f: @struct_field) {
vfn(f.node.id);
},
visit_struct_method: fn@(_m: @method) {
}
visit_ty_method: |_| {},
visit_trait_method: |_| {},
visit_struct_def: |_, _, _, _| {},
visit_struct_field: |f| vfn(f.node.id),
visit_struct_method: |_| {}
})
}
pub fn visit_ids_for_inlined_item(item: inlined_item, vfn: fn@(node_id)) {
pub fn visit_ids_for_inlined_item(item: inlined_item, vfn: @fn(node_id)) {
item.accept((), id_visitor(vfn));
}
pub fn compute_id_range(visit_ids_fn: fn(fn@(node_id))) -> id_range {
pub fn compute_id_range(visit_ids_fn: &fn(@fn(node_id))) -> id_range {
let min = @mut int::max_value;
let max = @mut int::min_value;
do visit_ids_fn |id| {

8
src/libsyntax/diagnostic.rs
View file

@ -23,8 +23,9 @@ use core::dvec::DVec;
use std::term;
pub type Emitter = fn@(cmsp: Option<(@codemap::CodeMap, span)>,
msg: &str, lvl: level);
pub type Emitter = @fn(cmsp: Option<(@codemap::CodeMap, span)>,
msg: &str,
lvl: level);
// a handler deals with errors; certain errors
// (fatal, bug, unimpl) may cause immediate exit,
@ -204,8 +205,7 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: &str) {
}
pub fn collect(messages: @DVec<~str>)
-> fn@(Option<(@codemap::CodeMap, span)>, &str, level)
{
-> @fn(Option<(@codemap::CodeMap, span)>, &str, level) {
let f: @fn(Option<(@codemap::CodeMap, span)>, &str, level) =
|_o, msg: &str, _l| { messages.push(msg.to_str()); };
f

24
src/libsyntax/ext/base.rs
View file

@ -37,29 +37,39 @@ pub struct MacroDef {
ext: SyntaxExtension
}
pub type ItemDecorator =
fn@(ext_ctxt, span, @ast::meta_item, ~[@ast::item]) -> ~[@ast::item];
pub type ItemDecorator = @fn(ext_ctxt,
span,
@ast::meta_item,
~[@ast::item])
-> ~[@ast::item];
pub struct SyntaxExpanderTT {
expander: SyntaxExpanderTTFun,
span: Option<span>
}
pub type SyntaxExpanderTTFun
= fn@(ext_ctxt, span, &[ast::token_tree]) -> MacResult;
pub type SyntaxExpanderTTFun = @fn(ext_ctxt,
span,
&[ast::token_tree])
-> MacResult;
pub struct SyntaxExpanderTTItem {
expander: SyntaxExpanderTTItemFun,
span: Option<span>
}
pub type SyntaxExpanderTTItemFun
= fn@(ext_ctxt, span, ast::ident, ~[ast::token_tree]) -> MacResult;
pub type SyntaxExpanderTTItemFun = @fn(ext_ctxt,
span,
ast::ident,
~[ast::token_tree])
-> MacResult;
pub enum MacResult {
MRExpr(@ast::expr),
MRItem(@ast::item),
MRAny(fn@()-> @ast::expr, fn@()-> Option<@ast::item>, fn@()->@ast::stmt),
MRAny(@fn() -> @ast::expr,
@fn() -> Option<@ast::item>,
@fn() -> @ast::stmt),
MRDef(MacroDef)
}

42
src/libsyntax/ext/expand.rs
View file

@ -26,9 +26,12 @@ use core::option;
use core::vec;
use core::hashmap::LinearMap;
pub fn expand_expr(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
e: &expr_, s: span, fld: ast_fold,
orig: fn@(&expr_, span, ast_fold) -> (expr_, span))
pub fn expand_expr(extsbox: @mut SyntaxEnv,
cx: ext_ctxt,
e: &expr_,
s: span,
fld: ast_fold,
orig: @fn(&expr_, span, ast_fold) -> (expr_, span))
-> (expr_, span) {
match *e {
// expr_mac should really be expr_ext or something; it's the
@ -105,9 +108,11 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
//
// NB: there is some redundancy between this and expand_item, below, and
// they might benefit from some amount of semantic and language-UI merger.
pub fn expand_mod_items(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
module_: &ast::_mod, fld: ast_fold,
orig: fn@(&ast::_mod, ast_fold) -> ast::_mod)
pub fn expand_mod_items(extsbox: @mut SyntaxEnv,
cx: ext_ctxt,
module_: &ast::_mod,
fld: ast_fold,
orig: @fn(&ast::_mod, ast_fold) -> ast::_mod)
-> ast::_mod {
// Fold the contents first:
let module_ = orig(module_, fld);
@ -155,8 +160,10 @@ macro_rules! with_exts_frame (
// When we enter a module, record it, for the sake of `module!`
pub fn expand_item(extsbox: @mut SyntaxEnv,
cx: ext_ctxt, it: @ast::item, fld: ast_fold,
orig: fn@(@ast::item, ast_fold) -> Option<@ast::item>)
cx: ext_ctxt,
it: @ast::item,
fld: ast_fold,
orig: @fn(@ast::item, ast_fold) -> Option<@ast::item>)
-> Option<@ast::item> {
// need to do expansion first... it might turn out to be a module.
let maybe_it = match it.node {
@ -296,11 +303,13 @@ pub fn expand_item_mac(+extsbox: @mut SyntaxEnv,
}
// expand a stmt
pub fn expand_stmt(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
s: &stmt_, sp: span, fld: ast_fold,
orig: fn@(s: &stmt_, span, ast_fold) -> (stmt_, span))
pub fn expand_stmt(extsbox: @mut SyntaxEnv,
cx: ext_ctxt,
s: &stmt_,
sp: span,
fld: ast_fold,
orig: @fn(&stmt_, span, ast_fold) -> (stmt_, span))
-> (stmt_, span) {
let (mac, pth, tts, semi) = match *s {
stmt_mac(ref mac, semi) => {
match mac.node {
@ -356,9 +365,12 @@ pub fn expand_stmt(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
pub fn expand_block(extsbox: @mut SyntaxEnv, cx: ext_ctxt,
blk: &blk_, sp: span, fld: ast_fold,
orig: fn@(&blk_, span, ast_fold) -> (blk_, span))
pub fn expand_block(extsbox: @mut SyntaxEnv,
cx: ext_ctxt,
blk: &blk_,
sp: span,
fld: ast_fold,
orig: @fn(&blk_, span, ast_fold) -> (blk_, span))
-> (blk_, span) {
match (*extsbox).find(&@~" block") {
// no scope limit on macros in this block, no need

4
src/libsyntax/ext/fmt.rs
View file

@ -42,9 +42,7 @@ pub fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: &[ast::token_tree])
fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: &str) -> ! {
cx.span_fatal(sp, msg);
}
let parse_fmt_err = fn@(s: &str) -> ! {
parse_fmt_err_(cx, fmtspan, s)
};
let parse_fmt_err: @fn(&str) -> ! = |s| parse_fmt_err_(cx, fmtspan, s);
let pieces = parse_fmt_string(fmt, parse_fmt_err);
MRExpr(pieces_to_expr(cx, sp, pieces, args))
}

69
src/libsyntax/fold.rs
View file

@ -39,7 +39,7 @@ pub trait ast_fold {
fn fold_ident(@self, ident) -> ident;
fn fold_path(@self, @path) -> @path;
fn fold_local(@self, @local) -> @local;
fn map_exprs(@self, fn@(@expr) -> @expr, &[@expr]) -> ~[@expr];
fn map_exprs(@self, @fn(@expr) -> @expr, &[@expr]) -> ~[@expr];
fn new_id(@self, node_id) -> node_id;
fn new_span(@self, span) -> span;
}
@ -48,29 +48,29 @@ pub trait ast_fold {
pub struct AstFoldFns {
//unlike the others, item_ is non-trivial
fold_crate: fn@(&crate_, span, ast_fold) -> (crate_, span),
fold_view_item: fn@(view_item_, ast_fold) -> view_item_,
fold_foreign_item: fn@(@foreign_item, ast_fold) -> @foreign_item,
fold_item: fn@(@item, ast_fold) -> Option<@item>,
fold_struct_field: fn@(@struct_field, ast_fold) -> @struct_field,
fold_item_underscore: fn@(&item_, ast_fold) -> item_,
fold_method: fn@(@method, ast_fold) -> @method,
fold_block: fn@(&blk_, span, ast_fold) -> (blk_, span),
fold_stmt: fn@(&stmt_, span, ast_fold) -> (stmt_, span),
fold_arm: fn@(&arm, ast_fold) -> arm,
fold_pat: fn@(&pat_, span, ast_fold) -> (pat_, span),
fold_decl: fn@(&decl_, span, ast_fold) -> (decl_, span),
fold_expr: fn@(&expr_, span, ast_fold) -> (expr_, span),
fold_ty: fn@(&ty_, span, ast_fold) -> (ty_, span),
fold_mod: fn@(&_mod, ast_fold) -> _mod,
fold_foreign_mod: fn@(&foreign_mod, ast_fold) -> foreign_mod,
fold_variant: fn@(&variant_, span, ast_fold) -> (variant_, span),
fold_ident: fn@(ident, ast_fold) -> ident,
fold_path: fn@(@path, ast_fold) -> path,
fold_local: fn@(&local_, span, ast_fold) -> (local_, span),
map_exprs: fn@(fn@(@expr) -> @expr, &[@expr]) -> ~[@expr],
new_id: fn@(node_id) -> node_id,
new_span: fn@(span) -> span
fold_crate: @fn(&crate_, span, ast_fold) -> (crate_, span),
fold_view_item: @fn(view_item_, ast_fold) -> view_item_,
fold_foreign_item: @fn(@foreign_item, ast_fold) -> @foreign_item,
fold_item: @fn(@item, ast_fold) -> Option<@item>,
fold_struct_field: @fn(@struct_field, ast_fold) -> @struct_field,
fold_item_underscore: @fn(&item_, ast_fold) -> item_,
fold_method: @fn(@method, ast_fold) -> @method,
fold_block: @fn(&blk_, span, ast_fold) -> (blk_, span),
fold_stmt: @fn(&stmt_, span, ast_fold) -> (stmt_, span),
fold_arm: @fn(&arm, ast_fold) -> arm,
fold_pat: @fn(&pat_, span, ast_fold) -> (pat_, span),
fold_decl: @fn(&decl_, span, ast_fold) -> (decl_, span),
fold_expr: @fn(&expr_, span, ast_fold) -> (expr_, span),
fold_ty: @fn(&ty_, span, ast_fold) -> (ty_, span),
fold_mod: @fn(&_mod, ast_fold) -> _mod,
fold_foreign_mod: @fn(&foreign_mod, ast_fold) -> foreign_mod,
fold_variant: @fn(&variant_, span, ast_fold) -> (variant_, span),
fold_ident: @fn(ident, ast_fold) -> ident,
fold_path: @fn(@path, ast_fold) -> path,
fold_local: @fn(&local_, span, ast_fold) -> (local_, span),
map_exprs: @fn(@fn(@expr) -> @expr, &[@expr]) -> ~[@expr],
new_id: @fn(node_id) -> node_id,
new_span: @fn(span) -> span
}
pub type ast_fold_fns = @AstFoldFns;
@ -446,12 +446,12 @@ fn noop_fold_decl(d: &decl_, fld: @ast_fold) -> decl_ {
}
}
pub fn wrap<T>(f: fn@(&T, ast_fold) -> T)
-> fn@(&T, span, ast_fold) -> (T, span)
{
fn@(x: &T, s: span, fld: @ast_fold) -> (T, span) {
pub fn wrap<T>(f: @fn(&T, ast_fold) -> T)
-> @fn(&T, span, ast_fold) -> (T, span) {
let result: @fn(&T, span, @ast_fold) -> (T, span) = |x, s, fld| {
(f(x, fld), s)
}
};
result
}
pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
@ -759,7 +759,7 @@ fn noop_fold_local(l: &local_, fld: @ast_fold) -> local_ {
/* temporarily eta-expand because of a compiler bug with using `fn<T>` as a
value */
fn noop_map_exprs(f: fn@(@expr) -> @expr, es: &[@expr]) -> ~[@expr] {
fn noop_map_exprs(f: @fn(@expr) -> @expr, es: &[@expr]) -> ~[@expr] {
es.map(|x| f(*x))
}
@ -893,11 +893,10 @@ impl ast_fold for AstFoldFns {
let (n, s) = (self.fold_local)(&x.node, x.span, self as @ast_fold);
@spanned { node: n, span: (self.new_span)(s) }
}
fn map_exprs(
@self,
f: fn@(@expr) -> @expr,
e: &[@expr]
) -> ~[@expr] {
fn map_exprs(@self,
f: @fn(@expr) -> @expr,
e: &[@expr])
-> ~[@expr] {
(self.map_exprs)(f, e)
}
fn new_id(@self, node_id: ast::node_id) -> node_id {

4
src/libsyntax/parse/parser.rs
View file

@ -1822,8 +1822,8 @@ pub impl Parser {
|| self.parse_expr())
}
fn parse_lambda_expr_(parse_decl: fn&() -> fn_decl,
parse_body: fn&() -> @expr) -> @expr {
fn parse_lambda_expr_(parse_decl: &fn() -> fn_decl,
parse_body: &fn() -> @expr) -> @expr {
let lo = self.last_span.lo;
let decl = parse_decl();
let body = parse_body();

6
src/libsyntax/print/pprust.rs
View file

@ -47,8 +47,8 @@ pub enum ann_node/& {
node_pat(@ps, @ast::pat),
}
pub struct pp_ann {
pre: fn@(ann_node),
post: fn@(ann_node)
pre: @fn(ann_node),
post: @fn(ann_node)
}
pub fn no_ann() -> pp_ann {
@ -2190,7 +2190,7 @@ pub fn print_string(s: @ps, st: ~str) {
word(s.s, ~"\"");
}
pub fn to_str<T>(t: T, f: fn@(@ps, T), intr: @ident_interner) -> ~str {
pub fn to_str<T>(t: T, f: @fn(@ps, T), intr: @ident_interner) -> ~str {
do io::with_str_writer |wr| {
let s = rust_printer(wr, intr);
f(s, t);

139
src/libsyntax/visit.rs
View file

@ -71,27 +71,26 @@ pub fn generics_of_fn(fk: &fn_kind) -> Generics {
}
pub struct Visitor<E> {
visit_mod: fn@(&_mod, span, node_id, E, vt<E>),
visit_view_item: fn@(@view_item, E, vt<E>),
visit_foreign_item: fn@(@foreign_item, E, vt<E>),
visit_item: fn@(@item, E, vt<E>),
visit_local: fn@(@local, E, vt<E>),
visit_block: fn@(&blk, E, vt<E>),
visit_stmt: fn@(@stmt, E, vt<E>),
visit_arm: fn@(&arm, E, vt<E>),
visit_pat: fn@(@pat, E, vt<E>),
visit_decl: fn@(@decl, E, vt<E>),
visit_expr: fn@(@expr, E, vt<E>),
visit_expr_post: fn@(@expr, E, vt<E>),
visit_ty: fn@(@Ty, E, vt<E>),
visit_generics: fn@(&Generics, E, vt<E>),
visit_fn: fn@(&fn_kind, &fn_decl, &blk, span, node_id, E, vt<E>),
visit_ty_method: fn@(&ty_method, E, vt<E>),
visit_trait_method: fn@(&trait_method, E, vt<E>),
visit_struct_def: fn@(@struct_def, ident, &Generics, node_id, E,
vt<E>),
visit_struct_field: fn@(@struct_field, E, vt<E>),
visit_struct_method: fn@(@method, E, vt<E>)
visit_mod: @fn(&_mod, span, node_id, E, vt<E>),
visit_view_item: @fn(@view_item, E, vt<E>),
visit_foreign_item: @fn(@foreign_item, E, vt<E>),
visit_item: @fn(@item, E, vt<E>),
visit_local: @fn(@local, E, vt<E>),
visit_block: @fn(&blk, E, vt<E>),
visit_stmt: @fn(@stmt, E, vt<E>),
visit_arm: @fn(&arm, E, vt<E>),
visit_pat: @fn(@pat, E, vt<E>),
visit_decl: @fn(@decl, E, vt<E>),
visit_expr: @fn(@expr, E, vt<E>),
visit_expr_post: @fn(@expr, E, vt<E>),
visit_ty: @fn(@Ty, E, vt<E>),
visit_generics: @fn(&Generics, E, vt<E>),
visit_fn: @fn(&fn_kind, &fn_decl, &blk, span, node_id, E, vt<E>),
visit_ty_method: @fn(&ty_method, E, vt<E>),
visit_trait_method: @fn(&trait_method, E, vt<E>),
visit_struct_def: @fn(@struct_def, ident, &Generics, node_id, E, vt<E>),
visit_struct_field: @fn(@struct_field, E, vt<E>),
visit_struct_method: @fn(@method, E, vt<E>)
}
pub type visitor<E> = @Visitor<E>;
@ -603,26 +602,26 @@ pub fn visit_arm<E>(a: &arm, e: E, v: vt<E>) {
// calls the given functions on the nodes.
pub struct SimpleVisitor {
visit_mod: fn@(&_mod, span, node_id),
visit_view_item: fn@(@view_item),
visit_foreign_item: fn@(@foreign_item),
visit_item: fn@(@item),
visit_local: fn@(@local),
visit_block: fn@(&blk),
visit_stmt: fn@(@stmt),
visit_arm: fn@(&arm),
visit_pat: fn@(@pat),
visit_decl: fn@(@decl),
visit_expr: fn@(@expr),
visit_expr_post: fn@(@expr),
visit_ty: fn@(@Ty),
visit_generics: fn@(&Generics),
visit_fn: fn@(&fn_kind, &fn_decl, &blk, span, node_id),
visit_ty_method: fn@(&ty_method),
visit_trait_method: fn@(&trait_method),
visit_struct_def: fn@(@struct_def, ident, &Generics, node_id),
visit_struct_field: fn@(@struct_field),
visit_struct_method: fn@(@method)
visit_mod: @fn(&_mod, span, node_id),
visit_view_item: @fn(@view_item),
visit_foreign_item: @fn(@foreign_item),
visit_item: @fn(@item),
visit_local: @fn(@local),
visit_block: @fn(&blk),
visit_stmt: @fn(@stmt),
visit_arm: @fn(&arm),
visit_pat: @fn(@pat),
visit_decl: @fn(@decl),
visit_expr: @fn(@expr),
visit_expr_post: @fn(@expr),
visit_ty: @fn(@Ty),
visit_generics: @fn(&Generics),
visit_fn: @fn(&fn_kind, &fn_decl, &blk, span, node_id),
visit_ty_method: @fn(&ty_method),
visit_trait_method: @fn(&trait_method),
visit_struct_def: @fn(@struct_def, ident, &Generics, node_id),
visit_struct_field: @fn(@struct_field),
visit_struct_method: @fn(@method)
}
pub type simple_visitor = @SimpleVisitor;
@ -644,21 +643,19 @@ pub fn default_simple_visitor() -> @SimpleVisitor {
visit_expr: |_e| { },
visit_expr_post: |_e| { },
visit_ty: simple_ignore_ty,
visit_generics: fn@(_ps: &Generics) { },
visit_fn: fn@(_fk: &fn_kind, _d: &fn_decl, _b: &blk, _sp: span,
_id: node_id) { },
visit_ty_method: fn@(_m: &ty_method) { },
visit_trait_method: fn@(_m: &trait_method) { },
visit_struct_def: fn@(_sd: @struct_def, _nm: ident,
_generics: &Generics, _id: node_id) { },
visit_struct_field: fn@(_f: @struct_field) { },
visit_struct_method: fn@(_m: @method) { }
visit_generics: |_| {},
visit_fn: |_, _, _, _, _| {},
visit_ty_method: |_| {},
visit_trait_method: |_| {},
visit_struct_def: |_, _, _, _| {},
visit_struct_field: |_| {},
visit_struct_method: |_| {},
}
}
pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
fn v_mod(
f: fn@(&_mod, span, node_id),
f: @fn(&_mod, span, node_id),
m: &_mod,
sp: span,
id: node_id,
@ -668,65 +665,67 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
f(m, sp, id);
visit_mod(m, sp, id, e, v);
}
fn v_view_item(f: fn@(@view_item), vi: @view_item, &&e: (), v: vt<()>) {
fn v_view_item(f: @fn(@view_item), vi: @view_item, &&e: (), v: vt<()>) {
f(vi);
visit_view_item(vi, e, v);
}
fn v_foreign_item(f: fn@(@foreign_item), ni: @foreign_item, &&e: (),
fn v_foreign_item(f: @fn(@foreign_item), ni: @foreign_item, &&e: (),
v: vt<()>) {
f(ni);
visit_foreign_item(ni, e, v);
}
fn v_item(f: fn@(@item), i: @item, &&e: (), v: vt<()>) {
fn v_item(f: @fn(@item), i: @item, &&e: (), v: vt<()>) {
f(i);
visit_item(i, e, v);
}
fn v_local(f: fn@(@local), l: @local, &&e: (), v: vt<()>) {
fn v_local(f: @fn(@local), l: @local, &&e: (), v: vt<()>) {
f(l);
visit_local(l, e, v);
}
fn v_block(f: fn@(&blk), bl: &blk, &&e: (), v: vt<()>) {
fn v_block(f: @fn(&ast::blk), bl: &ast::blk, &&e: (), v: vt<()>) {
f(bl);
visit_block(bl, e, v);
}
fn v_stmt(f: fn@(@stmt), st: @stmt, &&e: (), v: vt<()>) {
fn v_stmt(f: @fn(@stmt), st: @stmt, &&e: (), v: vt<()>) {
f(st);
visit_stmt(st, e, v);
}
fn v_arm(f: fn@(&arm), a: &arm, &&e: (), v: vt<()>) {
fn v_arm(f: @fn(&arm), a: &arm, &&e: (), v: vt<()>) {
f(a);
visit_arm(a, e, v);
}
fn v_pat(f: fn@(@pat), p: @pat, &&e: (), v: vt<()>) {
fn v_pat(f: @fn(@pat), p: @pat, &&e: (), v: vt<()>) {
f(p);
visit_pat(p, e, v);
}
fn v_decl(f: fn@(@decl), d: @decl, &&e: (), v: vt<()>) {
fn v_decl(f: @fn(@decl), d: @decl, &&e: (), v: vt<()>) {
f(d);
visit_decl(d, e, v);
}
fn v_expr(f: fn@(@expr), ex: @expr, &&e: (), v: vt<()>) {
fn v_expr(f: @fn(@expr), ex: @expr, &&e: (), v: vt<()>) {
f(ex);
visit_expr(ex, e, v);
}
fn v_expr_post(f: fn@(@expr), ex: @expr, &&_e: (), _v: vt<()>) {
fn v_expr_post(f: @fn(@expr), ex: @expr, &&_e: (), _v: vt<()>) {
f(ex);
}
fn v_ty(f: fn@(@Ty), ty: @Ty, &&e: (), v: vt<()>) {
fn v_ty(f: @fn(@Ty), ty: @Ty, &&e: (), v: vt<()>) {
f(ty);
visit_ty(ty, e, v);
}
fn v_ty_method(f: fn@(&ty_method), ty: &ty_method, &&e: (), v: vt<()>) {
fn v_ty_method(f: @fn(&ty_method), ty: &ty_method, &&e: (), v: vt<()>) {
f(ty);
visit_ty_method(ty, e, v);
}
fn v_trait_method(f: fn@(&trait_method), m: &trait_method, &&e: (),
fn v_trait_method(f: @fn(&trait_method),
m: &trait_method,
&&e: (),
v: vt<()>) {
f(m);
visit_trait_method(m, e, v);
}
fn v_struct_def(
f: fn@(@struct_def, ident, &Generics, node_id),
f: @fn(@struct_def, ident, &Generics, node_id),
sd: @struct_def,
nm: ident,
generics: &Generics,
@ -738,7 +737,7 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
visit_struct_def(sd, nm, generics, id, e, v);
}
fn v_generics(
f: fn@(&Generics),
f: @fn(&Generics),
ps: &Generics,
&&e: (),
v: vt<()>
@ -747,7 +746,7 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
visit_generics(ps, e, v);
}
fn v_fn(
f: fn@(&fn_kind, &fn_decl, &blk, span, node_id),
f: @fn(&fn_kind, &fn_decl, &blk, span, node_id),
fk: &fn_kind,
decl: &fn_decl,
body: &blk,
@ -761,12 +760,12 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
}
let visit_ty: @fn(@Ty, &&x: (), vt<()>) =
|a,b,c| v_ty(v.visit_ty, a, b, c);
fn v_struct_field(f: fn@(@struct_field), sf: @struct_field, &&e: (),
fn v_struct_field(f: @fn(@struct_field), sf: @struct_field, &&e: (),
v: vt<()>) {
f(sf);
visit_struct_field(sf, e, v);
}
fn v_struct_method(f: fn@(@method), m: @method, &&e: (), v: vt<()>) {
fn v_struct_method(f: @fn(@method), m: @method, &&e: (), v: vt<()>) {
f(m);
visit_struct_method(m, e, v);
}