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

Author: pcwalton

src/libsyntax/ast_util.rs

@@ -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_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_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_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| {

src/libsyntax/diagnostic.rs

@@ -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

src/libsyntax/ext/base.rs

@@ -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)
 }
 

src/libsyntax/ext/expand.rs

@@ -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,10 +365,13 @@ 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))
-    -> (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
         // to push an exts frame:

src/libsyntax/ext/fmt.rs

@@ -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))
 }

src/libsyntax/fold.rs

@@ -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 {