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 range.min >= range.max
} }
pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> { pub fn id_visitor(vfn: @fn(node_id)) -> visit::vt<()> {
let visit_generics = fn@(generics: &Generics) { let visit_generics: @fn(&Generics) = |generics| {
for generics.ty_params.each |p| { for generics.ty_params.each |p| {
vfn(p.id); vfn(p.id);
} }
@ -408,7 +408,7 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
visit::mk_simple_visitor(@visit::SimpleVisitor { visit::mk_simple_visitor(@visit::SimpleVisitor {
visit_mod: |_m, _sp, id| vfn(id), visit_mod: |_m, _sp, id| vfn(id),
visit_view_item: fn@(vi: @view_item) { visit_view_item: |vi| {
match vi.node { match vi.node {
view_item_extern_mod(_, _, id) => vfn(id), view_item_extern_mod(_, _, id) => vfn(id),
view_item_use(ref vps) => { 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) { visit_foreign_item: |ni| vfn(ni.id),
vfn(ni.id)
},
visit_item: fn@(i: @item) { visit_item: |i| {
vfn(i.id); vfn(i.id);
match i.node { match i.node {
item_enum(ref enum_definition, _) => item_enum(ref enum_definition, _) =>
@ -436,36 +434,21 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
} }
}, },
visit_local: fn@(l: @local) { visit_local: |l| vfn(l.node.id),
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) { visit_expr: |e| {
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) {
vfn(e.callee_id); vfn(e.callee_id);
vfn(e.id); vfn(e.id);
}, },
visit_expr_post: fn@(_e: @expr) { visit_expr_post: |_| {},
},
visit_ty: fn@(t: @Ty) { visit_ty: |t| {
match t.node { match t.node {
ty_path(_, id) => vfn(id), ty_path(_, id) => vfn(id),
_ => { /* fall through */ } _ => { /* fall through */ }
@ -474,8 +457,7 @@ pub fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
visit_generics: visit_generics, visit_generics: visit_generics,
visit_fn: fn@(fk: &visit::fn_kind, d: &ast::fn_decl, visit_fn: |fk, d, _, _, id| {
_b: &ast::blk, _sp: span, id: ast::node_id) {
vfn(id); vfn(id);
match *fk { 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_ty_method: |_| {},
}, visit_trait_method: |_| {},
visit_struct_def: |_, _, _, _| {},
visit_trait_method: fn@(_ty_m: &trait_method) { visit_struct_field: |f| vfn(f.node.id),
}, visit_struct_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) {
}
}) })
} }
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)); 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 min = @mut int::max_value;
let max = @mut int::min_value; let max = @mut int::min_value;
do visit_ids_fn |id| { do visit_ids_fn |id| {

8
src/libsyntax/diagnostic.rs
View file

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

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

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

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

@ -26,9 +26,12 @@ use core::option;
use core::vec; use core::vec;
use core::hashmap::LinearMap; use core::hashmap::LinearMap;
pub fn expand_expr(extsbox: @mut SyntaxEnv, cx: ext_ctxt, pub fn expand_expr(extsbox: @mut SyntaxEnv,
e: &expr_, s: span, fld: ast_fold, cx: ext_ctxt,
orig: fn@(&expr_, span, ast_fold) -> (expr_, span)) e: &expr_,
s: span,
fld: ast_fold,
orig: @fn(&expr_, span, ast_fold) -> (expr_, span))
-> (expr_, span) { -> (expr_, span) {
match *e { match *e {
// expr_mac should really be expr_ext or something; it's the // 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 // NB: there is some redundancy between this and expand_item, below, and
// they might benefit from some amount of semantic and language-UI merger. // they might benefit from some amount of semantic and language-UI merger.
pub fn expand_mod_items(extsbox: @mut SyntaxEnv, cx: ext_ctxt, pub fn expand_mod_items(extsbox: @mut SyntaxEnv,
module_: &ast::_mod, fld: ast_fold, cx: ext_ctxt,
orig: fn@(&ast::_mod, ast_fold) -> ast::_mod) module_: &ast::_mod,
fld: ast_fold,
orig: @fn(&ast::_mod, ast_fold) -> ast::_mod)
-> ast::_mod { -> ast::_mod {
// Fold the contents first: // Fold the contents first:
let module_ = orig(module_, fld); 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!` // When we enter a module, record it, for the sake of `module!`
pub fn expand_item(extsbox: @mut SyntaxEnv, pub fn expand_item(extsbox: @mut SyntaxEnv,
cx: ext_ctxt, it: @ast::item, fld: ast_fold, cx: ext_ctxt,
orig: fn@(@ast::item, ast_fold) -> Option<@ast::item>) it: @ast::item,
fld: ast_fold,
orig: @fn(@ast::item, ast_fold) -> Option<@ast::item>)
-> Option<@ast::item> { -> Option<@ast::item> {
// need to do expansion first... it might turn out to be a module. // need to do expansion first... it might turn out to be a module.
let maybe_it = match it.node { let maybe_it = match it.node {
@ -296,11 +303,13 @@ pub fn expand_item_mac(+extsbox: @mut SyntaxEnv,
} }
// expand a stmt // expand a stmt
pub fn expand_stmt(extsbox: @mut SyntaxEnv, cx: ext_ctxt, pub fn expand_stmt(extsbox: @mut SyntaxEnv,
s: &stmt_, sp: span, fld: ast_fold, cx: ext_ctxt,
orig: fn@(s: &stmt_, span, ast_fold) -> (stmt_, span)) s: &stmt_,
sp: span,
fld: ast_fold,
orig: @fn(&stmt_, span, ast_fold) -> (stmt_, span))
-> (stmt_, span) { -> (stmt_, span) {
let (mac, pth, tts, semi) = match *s { let (mac, pth, tts, semi) = match *s {
stmt_mac(ref mac, semi) => { stmt_mac(ref mac, semi) => {
match mac.node { 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, pub fn expand_block(extsbox: @mut SyntaxEnv,
blk: &blk_, sp: span, fld: ast_fold, cx: ext_ctxt,
orig: fn@(&blk_, span, ast_fold) -> (blk_, span)) blk: &blk_,
sp: span,
fld: ast_fold,
orig: @fn(&blk_, span, ast_fold) -> (blk_, span))
-> (blk_, span) { -> (blk_, span) {
match (*extsbox).find(&@~" block") { match (*extsbox).find(&@~" block") {
// no scope limit on macros in this block, no need // 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) -> ! { fn parse_fmt_err_(cx: ext_ctxt, sp: span, msg: &str) -> ! {
cx.span_fatal(sp, msg); cx.span_fatal(sp, msg);
} }
let parse_fmt_err = fn@(s: &str) -> ! { let parse_fmt_err: @fn(&str) -> ! = |s| parse_fmt_err_(cx, fmtspan, s);
parse_fmt_err_(cx, fmtspan, s)
};
let pieces = parse_fmt_string(fmt, parse_fmt_err); let pieces = parse_fmt_string(fmt, parse_fmt_err);
MRExpr(pieces_to_expr(cx, sp, pieces, args)) 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_ident(@self, ident) -> ident;
fn fold_path(@self, @path) -> @path; fn fold_path(@self, @path) -> @path;
fn fold_local(@self, @local) -> @local; 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_id(@self, node_id) -> node_id;
fn new_span(@self, span) -> span; fn new_span(@self, span) -> span;
} }
@ -48,29 +48,29 @@ pub trait ast_fold {
pub struct AstFoldFns { pub struct AstFoldFns {
//unlike the others, item_ is non-trivial //unlike the others, item_ is non-trivial
fold_crate: fn@(&crate_, span, ast_fold) -> (crate_, span), fold_crate: @fn(&crate_, span, ast_fold) -> (crate_, span),
fold_view_item: fn@(view_item_, ast_fold) -> view_item_, fold_view_item: @fn(view_item_, ast_fold) -> view_item_,
fold_foreign_item: fn@(@foreign_item, ast_fold) -> @foreign_item, fold_foreign_item: @fn(@foreign_item, ast_fold) -> @foreign_item,
fold_item: fn@(@item, ast_fold) -> Option<@item>, fold_item: @fn(@item, ast_fold) -> Option<@item>,
fold_struct_field: fn@(@struct_field, ast_fold) -> @struct_field, fold_struct_field: @fn(@struct_field, ast_fold) -> @struct_field,
fold_item_underscore: fn@(&item_, ast_fold) -> item_, fold_item_underscore: @fn(&item_, ast_fold) -> item_,
fold_method: fn@(@method, ast_fold) -> @method, fold_method: @fn(@method, ast_fold) -> @method,
fold_block: fn@(&blk_, span, ast_fold) -> (blk_, span), fold_block: @fn(&blk_, span, ast_fold) -> (blk_, span),
fold_stmt: fn@(&stmt_, span, ast_fold) -> (stmt_, span), fold_stmt: @fn(&stmt_, span, ast_fold) -> (stmt_, span),
fold_arm: fn@(&arm, ast_fold) -> arm, fold_arm: @fn(&arm, ast_fold) -> arm,
fold_pat: fn@(&pat_, span, ast_fold) -> (pat_, span), fold_pat: @fn(&pat_, span, ast_fold) -> (pat_, span),
fold_decl: fn@(&decl_, span, ast_fold) -> (decl_, span), fold_decl: @fn(&decl_, span, ast_fold) -> (decl_, span),
fold_expr: fn@(&expr_, span, ast_fold) -> (expr_, span), fold_expr: @fn(&expr_, span, ast_fold) -> (expr_, span),
fold_ty: fn@(&ty_, span, ast_fold) -> (ty_, span), fold_ty: @fn(&ty_, span, ast_fold) -> (ty_, span),
fold_mod: fn@(&_mod, ast_fold) -> _mod, fold_mod: @fn(&_mod, ast_fold) -> _mod,
fold_foreign_mod: fn@(&foreign_mod, ast_fold) -> foreign_mod, fold_foreign_mod: @fn(&foreign_mod, ast_fold) -> foreign_mod,
fold_variant: fn@(&variant_, span, ast_fold) -> (variant_, span), fold_variant: @fn(&variant_, span, ast_fold) -> (variant_, span),
fold_ident: fn@(ident, ast_fold) -> ident, fold_ident: @fn(ident, ast_fold) -> ident,
fold_path: fn@(@path, ast_fold) -> path, fold_path: @fn(@path, ast_fold) -> path,
fold_local: fn@(&local_, span, ast_fold) -> (local_, span), fold_local: @fn(&local_, span, ast_fold) -> (local_, span),
map_exprs: fn@(fn@(@expr) -> @expr, &[@expr]) -> ~[@expr], map_exprs: @fn(@fn(@expr) -> @expr, &[@expr]) -> ~[@expr],
new_id: fn@(node_id) -> node_id, new_id: @fn(node_id) -> node_id,
new_span: fn@(span) -> span new_span: @fn(span) -> span
} }
pub type ast_fold_fns = @AstFoldFns; 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) pub fn wrap<T>(f: @fn(&T, ast_fold) -> T)
-> fn@(&T, span, ast_fold) -> (T, span) -> @fn(&T, span, ast_fold) -> (T, span) {
{ let result: @fn(&T, span, @ast_fold) -> (T, span) = |x, s, fld| {
fn@(x: &T, s: span, fld: @ast_fold) -> (T, span) {
(f(x, fld), s) (f(x, fld), s)
} };
result
} }
pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ { 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 /* temporarily eta-expand because of a compiler bug with using `fn<T>` as a
value */ 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)) 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); let (n, s) = (self.fold_local)(&x.node, x.span, self as @ast_fold);
@spanned { node: n, span: (self.new_span)(s) } @spanned { node: n, span: (self.new_span)(s) }
} }
fn map_exprs( fn map_exprs(@self,
@self, f: @fn(@expr) -> @expr,
f: fn@(@expr) -> @expr, e: &[@expr])
e: &[@expr] -> ~[@expr] {
) -> ~[@expr] {
(self.map_exprs)(f, e) (self.map_exprs)(f, e)
} }
fn new_id(@self, node_id: ast::node_id) -> node_id { 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()) || self.parse_expr())
} }
fn parse_lambda_expr_(parse_decl: fn&() -> fn_decl, fn parse_lambda_expr_(parse_decl: &fn() -> fn_decl,
parse_body: fn&() -> @expr) -> @expr { parse_body: &fn() -> @expr) -> @expr {
let lo = self.last_span.lo; let lo = self.last_span.lo;
let decl = parse_decl(); let decl = parse_decl();
let body = parse_body(); 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), node_pat(@ps, @ast::pat),
} }
pub struct pp_ann { pub struct pp_ann {
pre: fn@(ann_node), pre: @fn(ann_node),
post: fn@(ann_node) post: @fn(ann_node)
} }
pub fn no_ann() -> pp_ann { pub fn no_ann() -> pp_ann {
@ -2190,7 +2190,7 @@ pub fn print_string(s: @ps, st: ~str) {
word(s.s, ~"\""); 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| { do io::with_str_writer |wr| {
let s = rust_printer(wr, intr); let s = rust_printer(wr, intr);
f(s, t); 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> { pub struct Visitor<E> {
visit_mod: fn@(&_mod, span, node_id, E, vt<E>), visit_mod: @fn(&_mod, span, node_id, E, vt<E>),
visit_view_item: fn@(@view_item, E, vt<E>), visit_view_item: @fn(@view_item, E, vt<E>),
visit_foreign_item: fn@(@foreign_item, E, vt<E>), visit_foreign_item: @fn(@foreign_item, E, vt<E>),
visit_item: fn@(@item, E, vt<E>), visit_item: @fn(@item, E, vt<E>),
visit_local: fn@(@local, E, vt<E>), visit_local: @fn(@local, E, vt<E>),
visit_block: fn@(&blk, E, vt<E>), visit_block: @fn(&blk, E, vt<E>),
visit_stmt: fn@(@stmt, E, vt<E>), visit_stmt: @fn(@stmt, E, vt<E>),
visit_arm: fn@(&arm, E, vt<E>), visit_arm: @fn(&arm, E, vt<E>),
visit_pat: fn@(@pat, E, vt<E>), visit_pat: @fn(@pat, E, vt<E>),
visit_decl: fn@(@decl, E, vt<E>), visit_decl: @fn(@decl, E, vt<E>),
visit_expr: fn@(@expr, E, vt<E>), visit_expr: @fn(@expr, E, vt<E>),
visit_expr_post: fn@(@expr, E, vt<E>), visit_expr_post: @fn(@expr, E, vt<E>),
visit_ty: fn@(@Ty, E, vt<E>), visit_ty: @fn(@Ty, E, vt<E>),
visit_generics: fn@(&Generics, 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_fn: @fn(&fn_kind, &fn_decl, &blk, span, node_id, E, vt<E>),
visit_ty_method: fn@(&ty_method, E, vt<E>), visit_ty_method: @fn(&ty_method, E, vt<E>),
visit_trait_method: fn@(&trait_method, E, vt<E>), visit_trait_method: @fn(&trait_method, E, vt<E>),
visit_struct_def: fn@(@struct_def, ident, &Generics, node_id, E, visit_struct_def: @fn(@struct_def, ident, &Generics, node_id, E, vt<E>),
vt<E>), visit_struct_field: @fn(@struct_field, E, vt<E>),
visit_struct_field: fn@(@struct_field, E, vt<E>), visit_struct_method: @fn(@method, E, vt<E>)
visit_struct_method: fn@(@method, E, vt<E>)
} }
pub type visitor<E> = @Visitor<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. // calls the given functions on the nodes.
pub struct SimpleVisitor { pub struct SimpleVisitor {
visit_mod: fn@(&_mod, span, node_id), visit_mod: @fn(&_mod, span, node_id),
visit_view_item: fn@(@view_item), visit_view_item: @fn(@view_item),
visit_foreign_item: fn@(@foreign_item), visit_foreign_item: @fn(@foreign_item),
visit_item: fn@(@item), visit_item: @fn(@item),
visit_local: fn@(@local), visit_local: @fn(@local),
visit_block: fn@(&blk), visit_block: @fn(&blk),
visit_stmt: fn@(@stmt), visit_stmt: @fn(@stmt),
visit_arm: fn@(&arm), visit_arm: @fn(&arm),
visit_pat: fn@(@pat), visit_pat: @fn(@pat),
visit_decl: fn@(@decl), visit_decl: @fn(@decl),
visit_expr: fn@(@expr), visit_expr: @fn(@expr),
visit_expr_post: fn@(@expr), visit_expr_post: @fn(@expr),
visit_ty: fn@(@Ty), visit_ty: @fn(@Ty),
visit_generics: fn@(&Generics), visit_generics: @fn(&Generics),
visit_fn: fn@(&fn_kind, &fn_decl, &blk, span, node_id), visit_fn: @fn(&fn_kind, &fn_decl, &blk, span, node_id),
visit_ty_method: fn@(&ty_method), visit_ty_method: @fn(&ty_method),
visit_trait_method: fn@(&trait_method), visit_trait_method: @fn(&trait_method),
visit_struct_def: fn@(@struct_def, ident, &Generics, node_id), visit_struct_def: @fn(@struct_def, ident, &Generics, node_id),
visit_struct_field: fn@(@struct_field), visit_struct_field: @fn(@struct_field),
visit_struct_method: fn@(@method) visit_struct_method: @fn(@method)
} }
pub type simple_visitor = @SimpleVisitor; pub type simple_visitor = @SimpleVisitor;
@ -644,21 +643,19 @@ pub fn default_simple_visitor() -> @SimpleVisitor {
visit_expr: |_e| { }, visit_expr: |_e| { },
visit_expr_post: |_e| { }, visit_expr_post: |_e| { },
visit_ty: simple_ignore_ty, visit_ty: simple_ignore_ty,
visit_generics: fn@(_ps: &Generics) { }, visit_generics: |_| {},
visit_fn: fn@(_fk: &fn_kind, _d: &fn_decl, _b: &blk, _sp: span, visit_fn: |_, _, _, _, _| {},
_id: node_id) { }, visit_ty_method: |_| {},
visit_ty_method: fn@(_m: &ty_method) { }, visit_trait_method: |_| {},
visit_trait_method: fn@(_m: &trait_method) { }, visit_struct_def: |_, _, _, _| {},
visit_struct_def: fn@(_sd: @struct_def, _nm: ident, visit_struct_field: |_| {},
_generics: &Generics, _id: node_id) { }, visit_struct_method: |_| {},
visit_struct_field: fn@(_f: @struct_field) { },
visit_struct_method: fn@(_m: @method) { }
} }
} }
pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> { pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
fn v_mod( fn v_mod(
f: fn@(&_mod, span, node_id), f: @fn(&_mod, span, node_id),
m: &_mod, m: &_mod,
sp: span, sp: span,
id: node_id, id: node_id,
@ -668,65 +665,67 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
f(m, sp, id); f(m, sp, id);
visit_mod(m, sp, id, e, v); 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); f(vi);
visit_view_item(vi, e, v); 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<()>) { v: vt<()>) {
f(ni); f(ni);
visit_foreign_item(ni, e, v); 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); f(i);
visit_item(i, e, v); 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); f(l);
visit_local(l, e, v); 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); f(bl);
visit_block(bl, e, v); 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); f(st);
visit_stmt(st, e, v); 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); f(a);
visit_arm(a, e, v); 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); f(p);
visit_pat(p, e, v); 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); f(d);
visit_decl(d, e, v); 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); f(ex);
visit_expr(ex, e, v); 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); 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); f(ty);
visit_ty(ty, e, v); 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); f(ty);
visit_ty_method(ty, e, v); 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<()>) { v: vt<()>) {
f(m); f(m);
visit_trait_method(m, e, v); visit_trait_method(m, e, v);
} }
fn v_struct_def( fn v_struct_def(
f: fn@(@struct_def, ident, &Generics, node_id), f: @fn(@struct_def, ident, &Generics, node_id),
sd: @struct_def, sd: @struct_def,
nm: ident, nm: ident,
generics: &Generics, generics: &Generics,
@ -738,7 +737,7 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
visit_struct_def(sd, nm, generics, id, e, v); visit_struct_def(sd, nm, generics, id, e, v);
} }
fn v_generics( fn v_generics(
f: fn@(&Generics), f: @fn(&Generics),
ps: &Generics, ps: &Generics,
&&e: (), &&e: (),
v: vt<()> v: vt<()>
@ -747,7 +746,7 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
visit_generics(ps, e, v); visit_generics(ps, e, v);
} }
fn v_fn( 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, fk: &fn_kind,
decl: &fn_decl, decl: &fn_decl,
body: &blk, body: &blk,
@ -761,12 +760,12 @@ pub fn mk_simple_visitor(v: simple_visitor) -> vt<()> {
} }
let visit_ty: @fn(@Ty, &&x: (), vt<()>) = let visit_ty: @fn(@Ty, &&x: (), vt<()>) =
|a,b,c| v_ty(v.visit_ty, a, b, c); |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<()>) { v: vt<()>) {
f(sf); f(sf);
visit_struct_field(sf, e, v); 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); f(m);
visit_struct_method(m, e, v); visit_struct_method(m, e, v);
} }