From a3f728238bb49759a3b3b64599808c3265f2caca Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Fri, 1 Mar 2013 10:44:43 -0800
Subject: librustc: Forbid chained imports and fix the logic for one-level
 renaming imports

---
 src/libsyntax/parse/parser.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/libsyntax/parse/parser.rs')

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 4c48b49b5d6..b4a74d52fb6 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -61,10 +61,10 @@ use ast::{vstore_uniq};
 use ast;
 use ast_util::{ident_to_path, operator_prec};
 use ast_util;
-use classify;
 use codemap::{span,FssNone, BytePos, spanned, respan, mk_sp};
 use codemap;
 use parse::attr::parser_attr;
+use parse::classify;
 use parse::common::{seq_sep_none, token_to_str};
 use parse::common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed};
 use parse::lexer::reader;
-- 
cgit 1.4.1-3-g733a5


From 256afb8a1057fdbe7bca2860af1ddb6ef0768d5c Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Fri, 1 Mar 2013 13:30:06 -0800
Subject: libsyntax: Remove `fn@`, `fn~`, and `fn&` from libsyntax. rs=defun

---
 src/libsyntax/ast_util.rs     |  75 +++++++---------------
 src/libsyntax/diagnostic.rs   |   8 +--
 src/libsyntax/ext/base.rs     |  24 ++++---
 src/libsyntax/ext/expand.rs   |  44 ++++++++-----
 src/libsyntax/ext/fmt.rs      |   4 +-
 src/libsyntax/fold.rs         |  69 ++++++++++-----------
 src/libsyntax/parse/parser.rs |   4 +-
 src/libsyntax/print/pprust.rs |   6 +-
 src/libsyntax/visit.rs        | 141 +++++++++++++++++++++---------------------
 9 files changed, 181 insertions(+), 194 deletions(-)

(limited to 'src/libsyntax/parse/parser.rs')

diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 7e0cd2640b2..96f4dadb3db 100644
--- a/src/libsyntax/ast_util.rs
+++ b/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| {
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 27483ae94a5..ba4ec7fb6db 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/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
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 7d3c7cafa95..b3d3358e586 100644
--- a/src/libsyntax/ext/base.rs
+++ b/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)
 }
 
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index e3408a47c9a..858ce4b17a3 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/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:
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index c414f7a0b9c..af558e6b330 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/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))
 }
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index f820669ab1c..cd962d62e9c 100644
--- a/src/libsyntax/fold.rs
+++ b/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 {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index b4a74d52fb6..446c4b5f828 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -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();
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 282980f0faa..62907506d46 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -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);
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 5919271664e..5c4bd083f6a 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -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: (),
-                     v: vt<()>) {
+    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);
     }
-- 
cgit 1.4.1-3-g733a5


From ccec510f392d5017a1da37c6b8327b5201dffd2a Mon Sep 17 00:00:00 2001
From: Patrick Walton <pcwalton@mimiga.net>
Date: Fri, 1 Mar 2013 16:59:46 -0800
Subject: librustc: Stop parsing `fn@`, `fn~`, and `fn&`

---
 src/librustc/middle/borrowck/check_loans.rs  | 12 ++++-----
 src/librustc/middle/check_loop.rs            |  6 -----
 src/librustc/middle/freevars.rs              |  7 +-----
 src/librustc/middle/liveness.rs              |  9 +++----
 src/librustc/middle/mem_categorization.rs    |  2 +-
 src/librustc/middle/moves.rs                 |  1 -
 src/librustc/middle/resolve.rs               |  5 ++--
 src/librustc/middle/trans/debuginfo.rs       |  5 +---
 src/librustc/middle/trans/expr.rs            |  1 -
 src/librustc/middle/trans/type_use.rs        |  2 +-
 src/librustc/middle/ty.rs                    |  1 -
 src/librustc/middle/typeck/check/mod.rs      |  4 ---
 src/librustc/middle/typeck/check/regionck.rs |  3 +--
 src/libsyntax/ast.rs                         |  4 ---
 src/libsyntax/ext/env.rs                     |  2 +-
 src/libsyntax/ext/log_syntax.rs              |  2 +-
 src/libsyntax/ext/trace_macros.rs            |  2 +-
 src/libsyntax/fold.rs                        |  8 ------
 src/libsyntax/parse/parser.rs                | 37 +++-------------------------
 src/libsyntax/print/pprust.rs                | 11 ---------
 src/libsyntax/visit.rs                       | 11 ---------
 21 files changed, 22 insertions(+), 113 deletions(-)

(limited to 'src/libsyntax/parse/parser.rs')

diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs
index c3555e54519..d6af2f78626 100644
--- a/src/librustc/middle/borrowck/check_loans.rs
+++ b/src/librustc/middle/borrowck/check_loans.rs
@@ -212,8 +212,8 @@ pub impl CheckLoanCtxt {
                     (*self.fn_args).contains(&(did.node));
                 if is_fn_arg { return; } // case (a) above
               }
-              ast::expr_fn_block(*) | ast::expr_fn(*) |
-              ast::expr_loop_body(*) | ast::expr_do_body(*) => {
+              ast::expr_fn_block(*) | ast::expr_loop_body(*) |
+              ast::expr_do_body(*) => {
                 if self.is_stack_closure(expr.id) {
                     // case (b) above
                     return;
@@ -244,7 +244,7 @@ pub impl CheckLoanCtxt {
     }
 
     // True if the expression with the given `id` is a stack closure.
-    // The expression must be an expr_fn(*) or expr_fn_block(*)
+    // The expression must be an expr_fn_block(*)
     fn is_stack_closure(@mut self, id: ast::node_id) -> bool {
         let fn_ty = ty::node_id_to_type(self.tcx(), id);
         match ty::get(fn_ty).sty {
@@ -262,10 +262,8 @@ pub impl CheckLoanCtxt {
             did.crate == ast::local_crate &&
                 (*self.fn_args).contains(&(did.node))
           }
-          ast::expr_fn_block(*) | ast::expr_fn(*) => {
-            self.is_stack_closure(expr.id)
-          }
-          _ => false
+          ast::expr_fn_block(*) => self.is_stack_closure(expr.id),
+          _ => false,
         };
     }
 
diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs
index 15f64b0fa2f..74a79e5e560 100644
--- a/src/librustc/middle/check_loop.rs
+++ b/src/librustc/middle/check_loop.rs
@@ -38,12 +38,6 @@ pub fn check_crate(tcx: ty::ctxt, crate: @crate) {
               expr_loop(ref b, _) => {
                 (v.visit_block)(b, Context { in_loop: true,.. cx }, v);
               }
-              expr_fn(*) => {
-                visit::visit_expr(e, Context {
-                                        in_loop: false,
-                                        can_ret: true
-                                     }, v);
-              }
               expr_fn_block(_, ref b) => {
                 (v.visit_block)(b, Context {
                                          in_loop: false,
diff --git a/src/librustc/middle/freevars.rs b/src/librustc/middle/freevars.rs
index f26d5c7d11c..52520b59b44 100644
--- a/src/librustc/middle/freevars.rs
+++ b/src/librustc/middle/freevars.rs
@@ -49,12 +49,7 @@ fn collect_freevars(def_map: resolve::DefMap, blk: &ast::blk)
     let walk_expr: @fn(expr: @ast::expr, &&depth: int, v: visit::vt<int>) =
         |expr, depth, v| {
             match expr.node {
-              ast::expr_fn(_, _, _, _) => {
-                visit::visit_expr(expr, depth + 1, v);
-              }
-              ast::expr_fn_block(*) => {
-                visit::visit_expr(expr, depth + 1, v);
-              }
+              ast::expr_fn_block(*) => visit::visit_expr(expr, depth + 1, v),
               ast::expr_path(*) => {
                   let mut i = 0;
                   match def_map.find(&expr.id) {
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 5286fa1025a..95f28578fec 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -570,7 +570,6 @@ fn visit_expr(expr: @expr, &&self: @mut IrMaps, vt: vt<@mut IrMaps>) {
         }
         visit::visit_expr(expr, self, vt);
       }
-      expr_fn(*) |
       expr_fn_block(*) => {
         // Interesting control flow (for loops can contain labeled
         // breaks or continues)
@@ -1123,8 +1122,8 @@ pub impl Liveness {
               self.propagate_through_expr(e, succ)
           }
 
-          expr_fn(_, _, ref blk, _) | expr_fn_block(_, ref blk) => {
-              debug!("%s is an expr_fn or expr_fn_block",
+          expr_fn_block(_, ref blk) => {
+              debug!("%s is an expr_fn_block",
                    expr_to_str(expr, self.tcx.sess.intr()));
 
               /*
@@ -1592,7 +1591,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) {
         visit::visit_expr(expr, self, vt);
       }
 
-      expr_fn(*) | expr_fn_block(*) => {
+      expr_fn_block(*) => {
         let caps = self.ir.captures(expr);
         for caps.each |cap| {
             let var = self.variable(cap.var_nid, expr.span);
@@ -1794,7 +1793,7 @@ pub impl @Liveness {
         }
 
         match move_expr.node {
-            expr_fn(*) | expr_fn_block(*) => {
+            expr_fn_block(*) => {
                 self.report_illegal_read(
                     move_expr.span, lnk, var, MovedValue);
                 let name = self.ir.variable_name(var);
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index 7a6a434c41f..bcbb2d6fd17 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -441,7 +441,7 @@ pub impl mem_categorization_ctxt {
 
           ast::expr_addr_of(*) | ast::expr_call(*) |
           ast::expr_swap(*) | ast::expr_assign(*) |
-          ast::expr_assign_op(*) | ast::expr_fn(*) | ast::expr_fn_block(*) |
+          ast::expr_assign_op(*) | ast::expr_fn_block(*) |
           ast::expr_assert(*) | ast::expr_ret(*) |
           ast::expr_loop_body(*) | ast::expr_do_body(*) |
           ast::expr_unary(*) | ast::expr_method_call(*) |
diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs
index b9f35af37e0..c360b3a23e7 100644
--- a/src/librustc/middle/moves.rs
+++ b/src/librustc/middle/moves.rs
@@ -644,7 +644,6 @@ pub impl VisitContext {
                 self.use_expr(base, comp_mode, visitor);
             }
 
-            expr_fn(_, _, ref body, _) |
             expr_fn_block(_, ref body) => {
                 let cap_vars = self.compute_captures(expr.id);
                 self.move_maps.capture_map.insert(expr.id, cap_vars);
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 648b7e49204..5298f6c632d 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -34,12 +34,12 @@ use syntax::ast::{def_local, def_mod, def_prim_ty, def_region, def_self};
 use syntax::ast::{def_self_ty, def_static_method, def_struct, def_ty};
 use syntax::ast::{def_ty_param, def_typaram_binder};
 use syntax::ast::{def_upvar, def_use, def_variant, expr, expr_assign_op};
-use syntax::ast::{expr_binary, expr_break, expr_cast, expr_field, expr_fn};
+use syntax::ast::{expr_binary, expr_break, expr_cast, expr_field};
 use syntax::ast::{expr_fn_block, expr_index, expr_method_call, expr_path};
 use syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param};
 use syntax::ast::{def_upvar, def_use, def_variant, div, eq};
 use syntax::ast::{enum_variant_kind, expr, expr_again, expr_assign_op};
-use syntax::ast::{expr_fn_block, expr_index, expr_loop};
+use syntax::ast::{expr_index, expr_loop};
 use syntax::ast::{expr_path, expr_struct, expr_unary, fn_decl};
 use syntax::ast::{foreign_item, foreign_item_const, foreign_item_fn, ge};
 use syntax::ast::{Generics};
@@ -4810,7 +4810,6 @@ pub impl Resolver {
                 visit_expr(expr, (), visitor);
             }
 
-            expr_fn(_, ref fn_decl, ref block, _) |
             expr_fn_block(ref fn_decl, ref block) => {
                 self.resolve_function(FunctionRibKind(expr.id, block.node.id),
                                       Some(@/*bad*/copy *fn_decl),
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index 8a28769756e..d6c691f6667 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -869,15 +869,12 @@ pub fn create_function(fcx: fn_ctxt) -> @Metadata<SubProgramMetadata> {
       }
       ast_map::node_expr(expr) => {
         match /*bad*/copy expr.node {
-          ast::expr_fn(_, decl, _, _) => {
-            ((dbg_cx.names)(~"fn"), decl.output, expr.id)
-          }
           ast::expr_fn_block(decl, _) => {
             ((dbg_cx.names)(~"fn"), decl.output, expr.id)
           }
           _ => fcx.ccx.sess.span_bug(expr.span,
                                      ~"create_function: \
-                                       expected an expr_fn or fn_block here")
+                                       expected an expr_fn_block here")
         }
       }
       ast_map::node_dtor(_, _, did, _) => {
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 7fe2bd605e9..74cebaee2da 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -619,7 +619,6 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
         ast::expr_vec(*) | ast::expr_repeat(*) => {
             return tvec::trans_fixed_vstore(bcx, expr, expr, dest);
         }
-        ast::expr_fn(_, ref decl, ref body, _) |
         ast::expr_fn_block(ref decl, ref body) => {
             let expr_ty = expr_ty(bcx, expr);
             let sigil = ty::ty_closure_sigil(expr_ty);
diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs
index ff92f265cc0..7b7a6eee92e 100644
--- a/src/librustc/middle/trans/type_use.rs
+++ b/src/librustc/middle/trans/type_use.rs
@@ -301,7 +301,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) {
             }
         }
       }
-      expr_fn(*) | expr_fn_block(*) => {
+      expr_fn_block(*) => {
           match ty::ty_closure_sigil(ty::expr_ty(cx.ccx.tcx, e)) {
               ast::OwnedSigil => {}
               ast::BorrowedSigil | ast::ManagedSigil => {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 7acc1348613..0b0715dd9ca 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -3124,7 +3124,6 @@ pub fn expr_kind(tcx: ctxt,
         ast::expr_tup(*) |
         ast::expr_if(*) |
         ast::expr_match(*) |
-        ast::expr_fn(*) |
         ast::expr_fn_block(*) |
         ast::expr_loop_body(*) |
         ast::expr_do_body(*) |
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index a20eee8f981..f724a442902 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -2373,10 +2373,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
       ast::expr_match(discrim, ref arms) => {
         bot = _match::check_match(fcx, expr, discrim, (/*bad*/copy *arms));
       }
-      ast::expr_fn(sigil, ref decl, ref body, _) => {
-        check_expr_fn(fcx, expr, Some(sigil),
-                      decl, body, Vanilla, expected);
-      }
       ast::expr_fn_block(ref decl, ref body) => {
         check_expr_fn(fcx, expr, None,
                       decl, body, Vanilla, expected);
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index 1f2dfe7192f..8a772665072 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -282,7 +282,7 @@ pub fn visit_expr(expr: @ast::expr, &&rcx: @mut Rcx, v: rvt) {
             guarantor::for_match(rcx, discr, *arms);
         }
 
-        ast::expr_fn(*) | ast::expr_fn_block(*) => {
+        ast::expr_fn_block(*) => {
             let function_type = rcx.resolve_node_type(expr.id);
             match ty::get(function_type).sty {
                 ty::ty_closure(ty::ClosureTy {sigil: ast::BorrowedSigil,
@@ -708,7 +708,6 @@ pub mod guarantor {
             ast::expr_tup(*) |
             ast::expr_if(*) |
             ast::expr_match(*) |
-            ast::expr_fn(*) |
             ast::expr_fn_block(*) |
             ast::expr_loop_body(*) |
             ast::expr_do_body(*) |
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 1053473a3a5..cec35b429b4 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -571,10 +571,6 @@ pub enum expr_ {
        (implicit) condition is always true. */
     expr_loop(blk, Option<ident>),
     expr_match(@expr, ~[arm]),
-
-    // FIXME(#4717) the @() is req'd on windows or else LLVM croaks
-    expr_fn(Sigil, fn_decl, blk, @()),
-
     expr_fn_block(fn_decl, blk),
     // Inner expr is always an expr_fn_block. We need the wrapping node to
     // easily type this (a function returning nil on the inside but bool on
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index 91a9de9c051..c8fb83224ac 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -15,7 +15,7 @@
  * interface.
  */
 
-use prelude::*;
+use core::prelude::*;
 
 use ast;
 use codemap::span;
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
index 368520acd2d..9072f4bdd01 100644
--- a/src/libsyntax/ext/log_syntax.rs
+++ b/src/libsyntax/ext/log_syntax.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::*;
 use core::io::WriterUtil;
+use core::prelude::*;
 
 use ast;
 use codemap;
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
index bb6d656d5cc..d7f7f7c6510 100644
--- a/src/libsyntax/ext/trace_macros.rs
+++ b/src/libsyntax/ext/trace_macros.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::*;
+use core::prelude::*;
 
 use ast::tt_delim;
 use ast;
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index cd962d62e9c..b315e543f5f 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -533,14 +533,6 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ {
                 arms.map(|x| fld.fold_arm(x))
             )
         }
-        expr_fn(proto, ref decl, ref body, _) => {
-            expr_fn(
-                proto,
-                fold_fn_decl(decl, fld),
-                fld.fold_block(body),
-                @()
-            )
-        }
         expr_fn_block(ref decl, ref body) => {
             expr_fn_block(
                 fold_fn_decl(decl, fld),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 446c4b5f828..a3df97b3ae4 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -23,7 +23,7 @@ use ast::{decl_local, default_blk, deref, div, enum_def, enum_variant_kind};
 use ast::{expl, expr, expr_, expr_addr_of, expr_match, expr_again};
 use ast::{expr_assert, expr_assign, expr_assign_op, expr_binary, expr_block};
 use ast::{expr_break, expr_call, expr_cast, expr_copy, expr_do_body};
-use ast::{expr_field, expr_fn, expr_fn_block, expr_if, expr_index};
+use ast::{expr_field, expr_fn_block, expr_if, expr_index};
 use ast::{expr_lit, expr_log, expr_loop, expr_loop_body, expr_mac};
 use ast::{expr_method_call, expr_paren, expr_path, expr_rec, expr_repeat};
 use ast::{expr_ret, expr_swap, expr_struct, expr_tup, expr_unary};
@@ -381,17 +381,8 @@ pub impl Parser {
         let purity = self.parse_purity();
         let onceness = parse_onceness(&self);
         self.expect_keyword(&~"fn");
-        let post_sigil = self.parse_fn_ty_sigil();
-
-        let sigil = match (pre_sigil, post_sigil) {
-            (None, None) => BorrowedSigil,
-            (Some(p), None) | (None, Some(p)) => p,
-            (Some(_), Some(_)) => {
-                self.fatal(~"cannot combine prefix and postfix \
-                             syntax for closure kind; note that \
-                             postfix syntax is obsolete");
-            }
-        };
+
+        let sigil = match pre_sigil { None => BorrowedSigil, Some(p) => p };
 
         let region = if pre_region_name.is_some() {
             Some(self.region_from_name(pre_region_name))
@@ -1150,15 +1141,6 @@ pub impl Parser {
             return self.parse_loop_expr();
         } else if self.eat_keyword(&~"match") {
             return self.parse_match_expr();
-        } else if self.eat_keyword(&~"fn") {
-            let opt_sigil = self.parse_fn_ty_sigil();
-            let sigil = match opt_sigil {
-                None => {
-                    self.fatal(~"fn expr are deprecated, use fn@")
-                }
-                Some(p) => { p }
-            };
-            return self.parse_fn_expr(sigil);
         } else if self.eat_keyword(&~"unsafe") {
             return self.parse_block_expr(lo, unsafe_blk);
         } else if *self.token == token::LBRACKET {
@@ -1775,19 +1757,6 @@ pub impl Parser {
         self.mk_expr(lo, hi, expr_if(cond, thn, els))
     }
 
-    fn parse_fn_expr(sigil: Sigil) -> @expr {
-        let lo = self.last_span.lo;
-
-        // if we want to allow fn expression argument types to be inferred in
-        // the future, just have to change parse_arg to parse_fn_block_arg.
-        let decl = self.parse_fn_decl(|p| p.parse_arg());
-
-        let body = self.parse_block();
-
-        self.mk_expr(lo, body.span.hi,
-                     expr_fn(sigil, decl, body, @()))
-    }
-
     // `|args| { ... }` like in `do` expressions
     fn parse_lambda_block_expr() -> @expr {
         self.parse_lambda_expr_(
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 62907506d46..f808a3be6bb 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1346,17 +1346,6 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) {
         }
         bclose_(s, expr.span, match_indent_unit);
       }
-      ast::expr_fn(sigil, ref decl, ref body, _) => {
-        // containing cbox, will be closed by print-block at }
-        cbox(s, indent_unit);
-        // head-box, will be closed by print-block at start
-        ibox(s, 0u);
-        print_fn_header_info(s, None, None, ast::Many,
-                             Some(sigil), ast::inherited);
-        print_fn_args_and_ret(s, decl, None);
-        space(s.s);
-        print_block(s, body);
-      }
       ast::expr_fn_block(ref decl, ref body) => {
         // in do/for blocks we don't want to show an empty
         // argument list, but at this point we don't know which
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 5c4bd083f6a..262754624cb 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -534,17 +534,6 @@ pub fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
             (v.visit_expr)(x, e, v);
             for arms.each |a| { (v.visit_arm)(a, e, v); }
         }
-        expr_fn(proto, ref decl, ref body, _) => {
-            (v.visit_fn)(
-                &fk_anon(proto),
-                decl,
-                body,
-                ex.span,
-                ex.id,
-                e,
-                v
-            );
-        }
         expr_fn_block(ref decl, ref body) => {
             (v.visit_fn)(
                 &fk_fn_block,
-- 
cgit 1.4.1-3-g733a5