From 7e3f20133a0f38e4f18dce9992d1b4c13215f91f Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Tue, 19 Nov 2013 13:22:03 -0800 Subject: [PATCH] librustc: Change most uses of `&fn()` to `||`. --- src/librustc/driver/session.rs | 3 +- src/librustc/front/config.rs | 2 +- src/librustc/metadata/csearch.rs | 22 +++++---- src/librustc/metadata/cstore.rs | 3 +- src/librustc/metadata/decoder.rs | 27 +++++------ src/librustc/metadata/encoder.rs | 7 ++- src/librustc/metadata/filesearch.rs | 5 +- src/librustc/metadata/tydecode.rs | 8 ++-- src/librustc/metadata/tyencode.rs | 2 +- src/librustc/middle/astencode.rs | 6 +-- src/librustc/middle/borrowck/check_loans.rs | 8 ++-- src/librustc/middle/borrowck/mod.rs | 2 +- src/librustc/middle/borrowck/move_data.rs | 16 +++---- src/librustc/middle/check_match.rs | 4 +- src/librustc/middle/dataflow.rs | 25 +++++----- src/librustc/middle/graph.rs | 22 +++++---- src/librustc/middle/kind.rs | 12 +++-- src/librustc/middle/lint.rs | 10 ++-- src/librustc/middle/liveness.rs | 23 +++++----- src/librustc/middle/mem_categorization.rs | 4 +- src/librustc/middle/moves.rs | 4 +- src/librustc/middle/pat_util.rs | 5 +- src/librustc/middle/resolve.rs | 26 +++++------ src/librustc/middle/trans/_match.rs | 3 +- src/librustc/middle/trans/base.rs | 36 +++++++++------ src/librustc/middle/trans/cabi_x86_64.rs | 6 +-- src/librustc/middle/trans/callee.rs | 2 +- src/librustc/middle/trans/closure.rs | 13 +++--- src/librustc/middle/trans/common.rs | 4 +- src/librustc/middle/trans/datum.rs | 2 +- src/librustc/middle/trans/debuginfo.rs | 6 +-- src/librustc/middle/trans/expr.rs | 10 ++-- src/librustc/middle/trans/foreign.rs | 12 +++-- src/librustc/middle/trans/reflect.rs | 2 +- src/librustc/middle/ty.rs | 46 ++++++++----------- src/librustc/middle/typeck/astconv.rs | 19 ++++---- src/librustc/middle/typeck/check/_match.rs | 2 +- src/librustc/middle/typeck/check/demand.rs | 8 ++-- src/librustc/middle/typeck/check/method.rs | 25 +++++----- src/librustc/middle/typeck/check/mod.rs | 20 ++++---- .../middle/typeck/check/regionmanip.rs | 21 ++++----- src/librustc/middle/typeck/coherence.rs | 2 +- src/librustc/middle/typeck/infer/coercion.rs | 4 +- src/librustc/middle/typeck/infer/glb.rs | 2 +- src/librustc/middle/typeck/infer/mod.rs | 33 +++++++------ .../typeck/infer/region_inference/doc.rs | 28 +++++------ .../typeck/infer/region_inference/mod.rs | 8 ++-- src/librustc/middle/typeck/mod.rs | 17 ++++--- src/librustc/middle/typeck/variance.rs | 4 +- src/librustc/util/common.rs | 8 ++-- src/librustc/util/ppaux.rs | 2 +- 51 files changed, 298 insertions(+), 293 deletions(-) diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index d08127501b4..f752b68fea5 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -386,8 +386,7 @@ pub fn basic_options() -> @options { } // Seems out of place, but it uses session, so I'm putting it here -pub fn expect(sess: Session, opt: Option, msg: &fn() -> ~str) - -> T { +pub fn expect(sess: Session, opt: Option, msg: || -> ~str) -> T { diagnostic::expect(sess.diagnostic(), opt, msg) } diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs index c11208b0d3e..296e8578cbe 100644 --- a/src/librustc/front/config.rs +++ b/src/librustc/front/config.rs @@ -42,7 +42,7 @@ fn fold_item_underscore(&self, item: &ast::item_) -> ast::item_ { } pub fn strip_items(crate: ast::Crate, - in_cfg: &fn(attrs: &[ast::Attribute]) -> bool) + in_cfg: |attrs: &[ast::Attribute]| -> bool) -> ast::Crate { let ctxt = Context { in_cfg: in_cfg, diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index fdda6b38462..9c9dba52453 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -44,7 +44,8 @@ pub fn get_type_param_count(cstore: @mut cstore::CStore, def: ast::DefId) /// Iterates over all the language items in the given crate. pub fn each_lang_item(cstore: @mut cstore::CStore, cnum: ast::CrateNum, - f: &fn(ast::NodeId, uint) -> bool) -> bool { + f: |ast::NodeId, uint| -> bool) + -> bool { let crate_data = cstore::get_crate_data(cstore, cnum); decoder::each_lang_item(crate_data, f) } @@ -52,8 +53,9 @@ pub fn each_lang_item(cstore: @mut cstore::CStore, /// Iterates over each child of the given item. pub fn each_child_of_item(cstore: @mut cstore::CStore, def_id: ast::DefId, - callback: &fn(decoder::DefLike, ast::Ident, - ast::visibility)) { + callback: |decoder::DefLike, + ast::Ident, + ast::visibility|) { let crate_data = cstore::get_crate_data(cstore, def_id.crate); let get_crate_data: decoder::GetCrateDataCb = |cnum| { cstore::get_crate_data(cstore, cnum) @@ -68,9 +70,9 @@ pub fn each_child_of_item(cstore: @mut cstore::CStore, /// Iterates over each top-level crate item. pub fn each_top_level_item_of_crate(cstore: @mut cstore::CStore, cnum: ast::CrateNum, - callback: &fn(decoder::DefLike, - ast::Ident, - ast::visibility)) { + callback: |decoder::DefLike, + ast::Ident, + ast::visibility|) { let crate_data = cstore::get_crate_data(cstore, cnum); let get_crate_data: decoder::GetCrateDataCb = |cnum| { cstore::get_crate_data(cstore, cnum) @@ -178,7 +180,7 @@ pub fn get_static_methods_if_impl(cstore: @mut cstore::CStore, pub fn get_item_attrs(cstore: @mut cstore::CStore, def_id: ast::DefId, - f: &fn(~[@ast::MetaItem])) { + f: |~[@ast::MetaItem]|) { let cdata = cstore::get_crate_data(cstore, def_id.crate); decoder::get_item_attrs(cdata, def_id.node, f) } @@ -262,21 +264,21 @@ pub fn get_item_visibility(cstore: @mut cstore::CStore, pub fn each_impl(cstore: @mut cstore::CStore, crate_num: ast::CrateNum, - callback: &fn(ast::DefId)) { + callback: |ast::DefId|) { let cdata = cstore::get_crate_data(cstore, crate_num); decoder::each_impl(cdata, callback) } pub fn each_implementation_for_type(cstore: @mut cstore::CStore, def_id: ast::DefId, - callback: &fn(ast::DefId)) { + callback: |ast::DefId|) { let cdata = cstore::get_crate_data(cstore, def_id.crate); decoder::each_implementation_for_type(cdata, def_id.node, callback) } pub fn each_implementation_for_trait(cstore: @mut cstore::CStore, def_id: ast::DefId, - callback: &fn(ast::DefId)) { + callback: |ast::DefId|) { let cdata = cstore::get_crate_data(cstore, def_id.crate); decoder::each_implementation_for_trait(cdata, def_id.node, callback) } diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 3c79ea2fe5e..135d1ac8ac0 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -82,8 +82,7 @@ pub fn have_crate_data(cstore: &CStore, cnum: ast::CrateNum) -> bool { cstore.metas.contains_key(&cnum) } -pub fn iter_crate_data(cstore: &CStore, - i: &fn(ast::CrateNum, @crate_metadata)) { +pub fn iter_crate_data(cstore: &CStore, i: |ast::CrateNum, @crate_metadata|) { for (&k, &v) in cstore.metas.iter() { i(k, v); } diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 0680968703f..fbe3d7bbe9e 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -51,7 +51,7 @@ // what crate that's in and give us a def_id that makes sense for the current // build. -fn lookup_hash(d: ebml::Doc, eq_fn: &fn(x:&[u8]) -> bool, hash: u64) -> +fn lookup_hash(d: ebml::Doc, eq_fn: |&[u8]| -> bool, hash: u64) -> Option { let index = reader::get_doc(d, tag_index); let table = reader::get_doc(index, tag_index_table); @@ -205,7 +205,7 @@ fn get_provided_source(d: ebml::Doc, cdata: Cmd) -> Option { } } -fn each_reexport(d: ebml::Doc, f: &fn(ebml::Doc) -> bool) -> bool { +fn each_reexport(d: ebml::Doc, f: |ebml::Doc| -> bool) -> bool { reader::tagged_docs(d, tag_items_data_item_reexport, f) } @@ -509,7 +509,7 @@ pub fn def_like_to_def(def_like: DefLike) -> ast::Def { } /// Iterates over the language items in the given crate. -pub fn each_lang_item(cdata: Cmd, f: &fn(ast::NodeId, uint) -> bool) -> bool { +pub fn each_lang_item(cdata: Cmd, f: |ast::NodeId, uint| -> bool) -> bool { let root = reader::Doc(cdata.data); let lang_items = reader::get_doc(root, tag_lang_items); do reader::tagged_docs(lang_items, tag_lang_items_item) |item_doc| { @@ -733,8 +733,9 @@ fn each_child_of_item_or_crate(intr: @ident_interner, cdata: Cmd, item_doc: ebml::Doc, get_crate_data: GetCrateDataCb, - callback: &fn(DefLike, ast::Ident, - ast::visibility)) { + callback: |DefLike, + ast::Ident, + ast::visibility|) { // Iterate over all children. let _ = do reader::tagged_docs(item_doc, tag_mod_child) |child_info_doc| { let child_def_id = reader::with_doc_data(child_info_doc, @@ -861,7 +862,7 @@ pub fn each_child_of_item(intr: @ident_interner, cdata: Cmd, id: ast::NodeId, get_crate_data: GetCrateDataCb, - callback: &fn(DefLike, ast::Ident, ast::visibility)) { + callback: |DefLike, ast::Ident, ast::visibility|) { // Find the item. let root_doc = reader::Doc(cdata.data); let items = reader::get_doc(root_doc, tag_items); @@ -881,8 +882,9 @@ pub fn each_child_of_item(intr: @ident_interner, pub fn each_top_level_item_of_crate(intr: @ident_interner, cdata: Cmd, get_crate_data: GetCrateDataCb, - callback: &fn(DefLike, ast::Ident, - ast::visibility)) { + callback: |DefLike, + ast::Ident, + ast::visibility|) { let root_doc = reader::Doc(cdata.data); let misc_info_doc = reader::get_doc(root_doc, tag_misc_info); let crate_items_doc = reader::get_doc(misc_info_doc, @@ -1201,8 +1203,7 @@ pub fn get_static_methods_if_impl(intr: @ident_interner, pub fn get_item_attrs(cdata: Cmd, node_id: ast::NodeId, - f: &fn(~[@ast::MetaItem])) { - + f: |~[@ast::MetaItem]|) { let item = lookup_item(node_id, cdata.data); do reader::tagged_docs(item, tag_attributes) |attributes| { do reader::tagged_docs(attributes, tag_attribute) |attribute| { @@ -1474,7 +1475,7 @@ pub fn translate_def_id(cdata: Cmd, did: ast::DefId) -> ast::DefId { } } -pub fn each_impl(cdata: Cmd, callback: &fn(ast::DefId)) { +pub fn each_impl(cdata: Cmd, callback: |ast::DefId|) { let impls_doc = reader::get_doc(reader::Doc(cdata.data), tag_impls); let _ = do reader::tagged_docs(impls_doc, tag_impls_impl) |impl_doc| { callback(item_def_id(impl_doc, cdata)); @@ -1484,7 +1485,7 @@ pub fn each_impl(cdata: Cmd, callback: &fn(ast::DefId)) { pub fn each_implementation_for_type(cdata: Cmd, id: ast::NodeId, - callback: &fn(ast::DefId)) { + callback: |ast::DefId|) { let item_doc = lookup_item(id, cdata.data); do reader::tagged_docs(item_doc, tag_items_data_item_inherent_impl) |impl_doc| { @@ -1496,7 +1497,7 @@ pub fn each_implementation_for_type(cdata: Cmd, pub fn each_implementation_for_trait(cdata: Cmd, id: ast::NodeId, - callback: &fn(ast::DefId)) { + callback: |ast::DefId|) { let item_doc = lookup_item(id, cdata.data); let _ = do reader::tagged_docs(item_doc, diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index be45bf81867..340a4241da2 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -535,8 +535,7 @@ fn encode_reexported_static_methods(ecx: &EncodeContext, /// * For enums, iterates through the node IDs of the variants. /// /// * For newtype structs, iterates through the node ID of the constructor. -fn each_auxiliary_node_id(item: @item, callback: &fn(NodeId) -> bool) - -> bool { +fn each_auxiliary_node_id(item: @item, callback: |NodeId| -> bool) -> bool { let mut continue_ = true; match item.node { item_enum(ref enum_def, _) => { @@ -912,7 +911,7 @@ fn add_to_index(item: @item, ebml_w: &writer::Encoder, index: @mut ~[entry]) { index.push(entry { val: item.id as i64, pos: ebml_w.writer.tell() }); } - let add_to_index: &fn() = || add_to_index(item, ebml_w, index); + let add_to_index: || = || add_to_index(item, ebml_w, index); debug!("encoding info for item at {}", ecx.tcx.sess.codemap.span_to_str(item.span)); @@ -1412,7 +1411,7 @@ fn create_index( fn encode_index( ebml_w: &mut writer::Encoder, buckets: ~[@~[entry]], - write_fn: &fn(@mut MemWriter, &T)) { + write_fn: |@mut MemWriter, &T|) { ebml_w.start_tag(tag_index); let mut bucket_locs = ~[]; ebml_w.start_tag(tag_index_buckets); diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 237c50ab294..32beb4bbaf3 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/src/librustc/metadata/filesearch.rs @@ -35,7 +35,7 @@ pub fn pick_file(file: Path, path: &Path) -> Option { pub trait FileSearch { fn sysroot(&self) -> @Path; - fn for_each_lib_search_path(&self, f: &fn(&Path) -> FileMatch); + fn for_each_lib_search_path(&self, f: |&Path| -> FileMatch); fn get_target_lib_path(&self) -> Path; fn get_target_lib_file_path(&self, file: &Path) -> Path; } @@ -51,7 +51,8 @@ struct FileSearchImpl { } impl FileSearch for FileSearchImpl { fn sysroot(&self) -> @Path { self.sysroot } - fn for_each_lib_search_path(&self, f: &fn(&Path) -> FileMatch) { + + fn for_each_lib_search_path(&self, f: |&Path| -> FileMatch) { let mut visited_dirs = HashSet::new(); let mut found = false; diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index 31561e730d5..281998b0811 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -79,9 +79,7 @@ fn next_byte(st: &mut PState) -> u8 { return b; } -fn scan(st: &mut PState, is_last: &fn(char) -> bool, - op: &fn(&[u8]) -> R) -> R -{ +fn scan(st: &mut PState, is_last: |char| -> bool, op: |&[u8]| -> R) -> R { let start_pos = st.pos; debug!("scan: '{}' (start)", st.data[st.pos] as char); while !is_last(st.data[st.pos] as char) { @@ -98,7 +96,7 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident { return parse_ident_(st, |a| is_last(last, a) ); } -fn parse_ident_(st: &mut PState, is_last: &fn(char) -> bool) -> ast::Ident { +fn parse_ident_(st: &mut PState, is_last: |char| -> bool) -> ast::Ident { let rslt = scan(st, is_last, str::from_utf8); return st.tcx.sess.ident_of(rslt); } @@ -292,7 +290,7 @@ fn parse_region(st: &mut PState, conv: conv_did) -> ty::Region { } } -fn parse_opt(st: &mut PState, f: &fn(&mut PState) -> T) -> Option { +fn parse_opt(st: &mut PState, f: |&mut PState| -> T) -> Option { match next(st) { 'n' => None, 's' => Some(f(st)), diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index 49afb29488d..f1207b07ada 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -120,7 +120,7 @@ fn enc_mt(w: @mut MemWriter, cx: @ctxt, mt: ty::mt) { enc_ty(w, cx, mt.ty); } -fn enc_opt(w: @mut MemWriter, t: Option, enc_f: &fn(T)) { +fn enc_opt(w: @mut MemWriter, t: Option, enc_f: |T|) { match t { None => mywrite!(w, "n"), Some(v) => { diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 97d46cd3a0b..7f8816bd613 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -845,14 +845,12 @@ fn emit_tpbt(&mut self, } trait write_tag_and_id { - fn tag(&mut self, tag_id: c::astencode_tag, f: &fn(&mut Self)); + fn tag(&mut self, tag_id: c::astencode_tag, f: |&mut Self|); fn id(&mut self, id: ast::NodeId); } impl write_tag_and_id for writer::Encoder { - fn tag(&mut self, - tag_id: c::astencode_tag, - f: &fn(&mut writer::Encoder)) { + fn tag(&mut self, tag_id: c::astencode_tag, f: |&mut writer::Encoder|) { self.start_tag(tag_id as uint); f(self); self.end_tag(); diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs index 77dec4ede10..d6aec7738a1 100644 --- a/src/librustc/middle/borrowck/check_loans.rs +++ b/src/librustc/middle/borrowck/check_loans.rs @@ -124,9 +124,7 @@ fn check_captured_variables(&self, closure_id: ast::NodeId, span: Span) { pub fn tcx(&self) -> ty::ctxt { self.bccx.tcx } - pub fn each_issued_loan(&self, - scope_id: ast::NodeId, - op: &fn(&Loan) -> bool) + pub fn each_issued_loan(&self, scope_id: ast::NodeId, op: |&Loan| -> bool) -> bool { //! Iterates over each loan that has been issued //! on entrance to `scope_id`, regardless of whether it is @@ -142,7 +140,7 @@ pub fn each_issued_loan(&self, pub fn each_in_scope_loan(&self, scope_id: ast::NodeId, - op: &fn(&Loan) -> bool) + op: |&Loan| -> bool) -> bool { //! Like `each_issued_loan()`, but only considers loans that are //! currently in scope. @@ -160,7 +158,7 @@ pub fn each_in_scope_loan(&self, pub fn each_in_scope_restriction(&self, scope_id: ast::NodeId, loan_path: @LoanPath, - op: &fn(&Loan, &Restriction) -> bool) + op: |&Loan, &Restriction| -> bool) -> bool { //! Iterates through all the in-scope restrictions for the //! given `loan_path` diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 55daff90e62..ef2c172acdf 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -533,7 +533,7 @@ pub fn mc_ctxt(&self) -> mc::mem_categorization_ctxt { pub fn cat_pattern(&self, cmt: mc::cmt, pat: @ast::Pat, - op: &fn(mc::cmt, @ast::Pat)) { + op: |mc::cmt, @ast::Pat|) { let mc = self.mc_ctxt(); mc.cat_pattern(cmt, pat, op); } diff --git a/src/librustc/middle/borrowck/move_data.rs b/src/librustc/middle/borrowck/move_data.rs index e0314209967..a0a9ba11db2 100644 --- a/src/librustc/middle/borrowck/move_data.rs +++ b/src/librustc/middle/borrowck/move_data.rs @@ -412,9 +412,7 @@ fn add_gen_kills(&self, } } - fn each_base_path(&self, - index: MovePathIndex, - f: &fn(MovePathIndex) -> bool) + fn each_base_path(&self, index: MovePathIndex, f: |MovePathIndex| -> bool) -> bool { let mut p = index; while p != InvalidMovePathIndex { @@ -428,7 +426,8 @@ fn each_base_path(&self, fn each_extending_path(&self, index: MovePathIndex, - f: &fn(MovePathIndex) -> bool) -> bool { + f: |MovePathIndex| -> bool) + -> bool { if !f(index) { return false; } @@ -446,7 +445,8 @@ fn each_extending_path(&self, fn each_applicable_move(&self, index0: MovePathIndex, - f: &fn(MoveIndex) -> bool) -> bool { + f: |MoveIndex| -> bool) + -> bool { let mut ret = true; do self.each_extending_path(index0) |index| { let mut p = self.path(index).first_move; @@ -505,7 +505,7 @@ pub fn new(move_data: @mut MoveData, pub fn each_path_moved_by(&self, id: ast::NodeId, - f: &fn(&Move, @LoanPath) -> bool) + f: |&Move, @LoanPath| -> bool) -> bool { /*! * Iterates through each path moved by `id` @@ -521,7 +521,7 @@ pub fn each_path_moved_by(&self, pub fn each_move_of(&self, id: ast::NodeId, loan_path: @LoanPath, - f: &fn(&Move, @LoanPath) -> bool) + f: |&Move, @LoanPath| -> bool) -> bool { /*! * Iterates through each move of `loan_path` (or some base path @@ -587,7 +587,7 @@ pub fn is_assignee(&self, pub fn each_assignment_of(&self, id: ast::NodeId, loan_path: @LoanPath, - f: &fn(&Assignment) -> bool) + f: |&Assignment| -> bool) -> bool { /*! * Iterates through every assignment to `loan_path` that diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs index 3885ebfc4b6..04d6266d405 100644 --- a/src/librustc/middle/check_match.rs +++ b/src/librustc/middle/check_match.rs @@ -121,7 +121,7 @@ fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) { for pat in arm.pats.iter() { // Check that we do not match against a static NaN (#6804) - let pat_matches_nan: &fn(&Pat) -> bool = |p| { + let pat_matches_nan: |&Pat| -> bool = |p| { match cx.tcx.def_map.find(&p.id) { Some(&DefStatic(did, false)) => { let const_expr = lookup_const_by_id(cx.tcx, did).unwrap(); @@ -900,7 +900,7 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt, } } - let check_move: &fn(&Pat, Option<@Pat>) = |p, sub| { + let check_move: |&Pat, Option<@Pat>| = |p, sub| { // check legality of moving out of the enum // x @ Foo(*) is legal, but x @ Foo(y) isn't. diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 6b46da06211..96970e13fcb 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -234,7 +234,8 @@ fn compute_id_range(&mut self, id: ast::NodeId) -> (uint, uint) { pub fn each_bit_on_entry_frozen(&self, id: ast::NodeId, - f: &fn(uint) -> bool) -> bool { + f: |uint| -> bool) + -> bool { //! Iterates through each bit that is set on entry to `id`. //! Only useful after `propagate()` has been called. if !self.nodeid_to_bitset.contains_key(&id) { @@ -249,7 +250,8 @@ pub fn each_bit_on_entry_frozen(&self, pub fn each_bit_on_entry(&mut self, id: ast::NodeId, - f: &fn(uint) -> bool) -> bool { + f: |uint| -> bool) + -> bool { //! Iterates through each bit that is set on entry to `id`. //! Only useful after `propagate()` has been called. @@ -260,9 +262,8 @@ pub fn each_bit_on_entry(&mut self, self.each_bit(on_entry, f) } - pub fn each_gen_bit(&mut self, - id: ast::NodeId, - f: &fn(uint) -> bool) -> bool { + pub fn each_gen_bit(&mut self, id: ast::NodeId, f: |uint| -> bool) + -> bool { //! Iterates through each bit in the gen set for `id`. let (start, end) = self.compute_id_range(id); @@ -272,9 +273,8 @@ pub fn each_gen_bit(&mut self, self.each_bit(gens, f) } - pub fn each_gen_bit_frozen(&self, - id: ast::NodeId, - f: &fn(uint) -> bool) -> bool { + pub fn each_gen_bit_frozen(&self, id: ast::NodeId, f: |uint| -> bool) + -> bool { //! Iterates through each bit in the gen set for `id`. if !self.nodeid_to_bitset.contains_key(&id) { return true; @@ -286,9 +286,7 @@ pub fn each_gen_bit_frozen(&self, self.each_bit(gens, f) } - fn each_bit(&self, - words: &[uint], - f: &fn(uint) -> bool) -> bool { + fn each_bit(&self, words: &[uint], f: |uint| -> bool) -> bool { //! Helper for iterating over the bits in a bit set. for (word_index, &word) in words.iter().enumerate() { @@ -978,9 +976,8 @@ fn join_bits(oper: &O, } #[inline] -fn bitwise(out_vec: &mut [uint], - in_vec: &[uint], - op: &fn(uint, uint) -> uint) -> bool { +fn bitwise(out_vec: &mut [uint], in_vec: &[uint], op: |uint, uint| -> uint) + -> bool { assert_eq!(out_vec.len(), in_vec.len()); let mut changed = false; for (out_elt, in_elt) in out_vec.mut_iter().zip(in_vec.iter()) { diff --git a/src/librustc/middle/graph.rs b/src/librustc/middle/graph.rs index 87dce84d23d..7a842364d1e 100644 --- a/src/librustc/middle/graph.rs +++ b/src/librustc/middle/graph.rs @@ -185,19 +185,20 @@ pub fn next_adjacent(&self, edge: EdgeIndex, dir: Direction) -> EdgeIndex { /////////////////////////////////////////////////////////////////////////// // Iterating over nodes, edges - pub fn each_node(&self, f: &fn(NodeIndex, &Node) -> bool) -> bool { + pub fn each_node(&self, f: |NodeIndex, &Node| -> bool) -> bool { //! Iterates over all edges defined in the graph. self.nodes.iter().enumerate().advance(|(i, node)| f(NodeIndex(i), node)) } - pub fn each_edge(&self, f: &fn(EdgeIndex, &Edge) -> bool) -> bool { + pub fn each_edge(&self, f: |EdgeIndex, &Edge| -> bool) -> bool { //! Iterates over all edges defined in the graph self.edges.iter().enumerate().advance(|(i, edge)| f(EdgeIndex(i), edge)) } pub fn each_outgoing_edge(&self, source: NodeIndex, - f: &fn(EdgeIndex, &Edge) -> bool) -> bool { + f: |EdgeIndex, &Edge| -> bool) + -> bool { //! Iterates over all outgoing edges from the node `from` self.each_adjacent_edge(source, Outgoing, f) @@ -205,7 +206,8 @@ pub fn each_outgoing_edge(&self, pub fn each_incoming_edge(&self, target: NodeIndex, - f: &fn(EdgeIndex, &Edge) -> bool) -> bool { + f: |EdgeIndex, &Edge| -> bool) + -> bool { //! Iterates over all incoming edges to the node `target` self.each_adjacent_edge(target, Incoming, f) @@ -214,7 +216,8 @@ pub fn each_incoming_edge(&self, pub fn each_adjacent_edge(&self, node: NodeIndex, dir: Direction, - f: &fn(EdgeIndex, &Edge) -> bool) -> bool { + f: |EdgeIndex, &Edge| -> bool) + -> bool { //! Iterates over all edges adjacent to the node `node` //! in the direction `dir` (either `Outgoing` or `Incoming) @@ -239,9 +242,10 @@ pub fn each_adjacent_edge(&self, // computation. pub fn iterate_until_fixed_point(&self, - op: &fn(iter_index: uint, - edge_index: EdgeIndex, - edge: &Edge) -> bool) { + op: |iter_index: uint, + edge_index: EdgeIndex, + edge: &Edge| + -> bool) { let mut iteration = 0; let mut changed = true; while changed { @@ -254,7 +258,7 @@ pub fn iterate_until_fixed_point(&self, } } -pub fn each_edge_index(max_edge_index: EdgeIndex, f: &fn(EdgeIndex) -> bool) { +pub fn each_edge_index(max_edge_index: EdgeIndex, f: |EdgeIndex| -> bool) { let mut i = 0; let n = *max_edge_index; while i < n { diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index a570160ce95..b6b1516d05a 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -167,8 +167,9 @@ fn check_item(cx: &mut Context, item: @item) { // Yields the appropriate function to check the kind of closed over // variables. `id` is the NodeId for some expression that creates the // closure. -fn with_appropriate_checker(cx: &Context, id: NodeId, - b: &fn(checker: &fn(&Context, @freevar_entry))) { +fn with_appropriate_checker(cx: &Context, + id: NodeId, + b: |checker: |&Context, @freevar_entry||) { fn check_for_uniq(cx: &Context, fv: &freevar_entry, bounds: ty::BuiltinBounds) { // all captured data must be owned, regardless of whether it is // moved in or copied in. @@ -351,9 +352,10 @@ fn check_ty(cx: &mut Context, aty: &Ty) { } // Calls "any_missing" if any bounds were missing. -pub fn check_builtin_bounds(cx: &Context, ty: ty::t, bounds: ty::BuiltinBounds, - any_missing: &fn(ty::BuiltinBounds)) -{ +pub fn check_builtin_bounds(cx: &Context, + ty: ty::t, + bounds: ty::BuiltinBounds, + any_missing: |ty::BuiltinBounds|) { let kind = ty::type_contents(cx.tcx, ty); let mut missing = ty::EmptyBuiltinBounds(); for bound in bounds.iter() { diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 9395ebefe87..24e76709ff5 100644 --- a/src/librustc/middle/lint.rs +++ b/src/librustc/middle/lint.rs @@ -417,8 +417,9 @@ fn span_lint(&self, lint: lint, span: Span, msg: &str) { * current lint context, call the provided function, then reset the * lints in effect to their previous state. */ - fn with_lint_attrs(&mut self, attrs: &[ast::Attribute], - f: &fn(&mut Context)) { + fn with_lint_attrs(&mut self, + attrs: &[ast::Attribute], + f: |&mut Context|) { // Parse all of the lint attributes, and then add them all to the // current dictionary of lint information. Along the way, keep a history // of what we changed so we can roll everything back after invoking the @@ -468,7 +469,7 @@ fn with_lint_attrs(&mut self, attrs: &[ast::Attribute], } } - fn visit_ids(&self, f: &fn(&mut ast_util::IdVisitor)) { + fn visit_ids(&self, f: |&mut ast_util::IdVisitor|) { let mut v = ast_util::IdVisitor { operation: self, pass_through_items: false, @@ -480,7 +481,8 @@ fn visit_ids(&self, f: &fn(&mut ast_util::IdVisitor)) { pub fn each_lint(sess: session::Session, attrs: &[ast::Attribute], - f: &fn(@ast::MetaItem, level, @str) -> bool) -> bool { + f: |@ast::MetaItem, level, @str| -> bool) + -> bool { let xs = [allow, warn, deny, forbid]; for &level in xs.iter() { let level_name = level_to_str(level); diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 05c154c5c8d..3220ab08ede 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -657,7 +657,7 @@ pub fn variable_from_def_map(&self, node_id: NodeId, span: Span) pub fn pat_bindings(&self, pat: @Pat, - f: &fn(LiveNode, Variable, Span, NodeId)) { + f: |LiveNode, Variable, Span, NodeId|) { let def_map = self.tcx.def_map; do pat_util::pat_bindings(def_map, pat) |_bm, p_id, sp, _n| { let ln = self.live_node(p_id, sp); @@ -668,7 +668,7 @@ pub fn pat_bindings(&self, pub fn arm_pats_bindings(&self, pats: &[@Pat], - f: &fn(LiveNode, Variable, Span, NodeId)) { + f: |LiveNode, Variable, Span, NodeId|) { // only consider the first pattern; any later patterns must have // the same bindings, and we also consider the first pattern to be // the "authoratative" set of ids @@ -729,7 +729,7 @@ pub fn assigned_on_exit(&self, ln: LiveNode, var: Variable) self.assigned_on_entry(self.successors[*ln], var) } - pub fn indices(&self, ln: LiveNode, op: &fn(uint)) { + pub fn indices(&self, ln: LiveNode, op: |uint|) { let node_base_idx = self.idx(ln, Variable(0)); for var_idx in range(0u, self.ir.num_vars) { op(node_base_idx + var_idx) @@ -739,7 +739,7 @@ pub fn indices(&self, ln: LiveNode, op: &fn(uint)) { pub fn indices2(&self, ln: LiveNode, succ_ln: LiveNode, - op: &fn(uint, uint)) { + op: |uint, uint|) { let node_base_idx = self.idx(ln, Variable(0u)); let succ_base_idx = self.idx(succ_ln, Variable(0u)); for var_idx in range(0u, self.ir.num_vars) { @@ -750,7 +750,7 @@ pub fn indices2(&self, pub fn write_vars(&self, wr: &mut io::Writer, ln: LiveNode, - test: &fn(uint) -> LiveNode) { + test: |uint| -> LiveNode) { let node_base_idx = self.idx(ln, Variable(0)); for var_idx in range(0u, self.ir.num_vars) { let idx = node_base_idx + var_idx; @@ -1406,12 +1406,13 @@ pub fn propagate_through_loop(&self, cond_ln } - pub fn with_loop_nodes(&self, - loop_node_id: NodeId, - break_ln: LiveNode, - cont_ln: LiveNode, - f: &fn() -> R) - -> R { + pub fn with_loop_nodes( + &self, + loop_node_id: NodeId, + break_ln: LiveNode, + cont_ln: LiveNode, + f: || -> R) + -> R { debug!("with_loop_nodes: {} {}", loop_node_id, *break_ln); self.loop_scope.push(loop_node_id); self.break_ln.insert(loop_node_id, break_ln); diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index d8f66419379..89e19631dae 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -63,7 +63,7 @@ pub enum categorization { cat_rvalue(ast::NodeId), // temporary val, argument is its scope cat_static_item, cat_copied_upvar(CopiedUpvar), // upvar copied into @fn or ~fn env - cat_stack_upvar(cmt), // by ref upvar from &fn + cat_stack_upvar(cmt), // by ref upvar from || cat_local(ast::NodeId), // local variable cat_arg(ast::NodeId), // formal argument cat_deref(cmt, uint, PointerKind), // deref of a ptr @@ -822,7 +822,7 @@ pub fn cat_downcast(&self, pub fn cat_pattern(&self, cmt: cmt, pat: @ast::Pat, - op: &fn(cmt, @ast::Pat)) { + op: |cmt, @ast::Pat|) { // Here, `cmt` is the categorization for the value being // matched and pat is the pattern it is being matched against. // diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 36a47578e27..8493a7e00dd 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -148,7 +148,7 @@ struct Foo { a: int, b: ~int } pub enum CaptureMode { CapCopy, // Copy the value into the closure. CapMove, // Move the value into the closure. - CapRef, // Reference directly from parent stack frame (used by `&fn()`). + CapRef, // Reference directly from parent stack frame (used by `||`). } #[deriving(Encodable, Decodable)] @@ -686,7 +686,7 @@ pub fn compute_captures(&mut self, fn_expr_id: NodeId) -> @[CaptureVar] { let sigil = ty::ty_closure_sigil(fn_ty); let freevars = freevars::get_freevars(self.tcx, fn_expr_id); if sigil == BorrowedSigil { - // &fn() captures everything by ref + // || captures everything by ref at_vec::from_fn(freevars.len(), |i| { let fvar = &freevars[i]; CaptureVar {def: fvar.def, span: fvar.span, mode: CapRef} diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 878f0876918..6e5cd2e0bf2 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -70,8 +70,9 @@ pub fn pat_is_binding_or_wild(dm: resolve::DefMap, pat: @Pat) -> bool { } } -pub fn pat_bindings(dm: resolve::DefMap, pat: @Pat, - it: &fn(BindingMode, NodeId, Span, &Path)) { +pub fn pat_bindings(dm: resolve::DefMap, + pat: @Pat, + it: |BindingMode, NodeId, Span, &Path|) { do walk_pat(pat) |p| { match p.node { PatIdent(binding_mode, ref pth, _) if pat_is_binding(dm, p) => { diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 4861fa19f7e..fdf2e170e32 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -1538,10 +1538,10 @@ fn build_reduced_graph_for_view_item(&mut self, /// Constructs the reduced graph for one foreign item. fn build_reduced_graph_for_foreign_item(&mut self, - foreign_item: @foreign_item, - parent: ReducedGraphParent, - f: &fn(&mut Resolver, - ReducedGraphParent)) { + foreign_item: @foreign_item, + parent: ReducedGraphParent, + f: |&mut Resolver, + ReducedGraphParent|) { let name = foreign_item.ident; let is_public = foreign_item.vis == ast::public; let (name_bindings, new_parent) = @@ -3331,7 +3331,7 @@ fn add_exports_for_module(&mut self, // generate a fake "implementation scope" containing all the // implementations thus found, for compatibility with old resolve pass. - fn with_scope(&mut self, name: Option, f: &fn(&mut Resolver)) { + fn with_scope(&mut self, name: Option, f: |&mut Resolver|) { let orig_module = self.current_module; // Move down in the graph. @@ -3692,8 +3692,8 @@ fn resolve_item(&mut self, item: @item) { } fn with_type_parameter_rib(&mut self, - type_parameters: TypeParameters, - f: &fn(&mut Resolver)) { + type_parameters: TypeParameters, + f: |&mut Resolver|) { match type_parameters { HasTypeParameters(generics, node_id, initial_index, rib_kind) => { @@ -3735,13 +3735,13 @@ fn with_type_parameter_rib(&mut self, } } - fn with_label_rib(&mut self, f: &fn(&mut Resolver)) { + fn with_label_rib(&mut self, f: |&mut Resolver|) { self.label_ribs.push(@Rib::new(NormalRibKind)); f(self); self.label_ribs.pop(); } - fn with_constant_rib(&mut self, f: &fn(&mut Resolver)) { + fn with_constant_rib(&mut self, f: |&mut Resolver|) { self.value_ribs.push(@Rib::new(ConstantItemRibKind)); self.type_ribs.push(@Rib::new(ConstantItemRibKind)); f(self); @@ -4888,7 +4888,7 @@ fn resolve_item_by_identifier_in_lexical_scope(&mut self, } } - fn with_no_errors(&mut self, f: &fn(&mut Resolver) -> T) -> T { + fn with_no_errors(&mut self, f: |&mut Resolver| -> T) -> T { self.emit_errors = false; let rs = f(self); self.emit_errors = true; @@ -4901,10 +4901,8 @@ fn resolve_error(&mut self, span: Span, s: &str) { } } - fn find_best_match_for_name(&mut self, - name: &str, - max_distance: uint) - -> Option<@str> { + fn find_best_match_for_name(&mut self, name: &str, max_distance: uint) + -> Option<@str> { let this = &mut *self; let mut maybes: ~[@str] = ~[]; diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index b48260de766..92913983d86 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -2066,7 +2066,8 @@ fn mk_binding_alloca(mut bcx: @mut Block, p_id: ast::NodeId, path: &ast::Path, binding_mode: IrrefutablePatternBindingMode, - populate: &fn(@mut Block, ty::t, ValueRef) -> @mut Block) -> @mut Block { + populate: |@mut Block, ty::t, ValueRef| -> @mut Block) + -> @mut Block { let var_ty = node_id_type(bcx, p_id); let ident = ast_util::path_to_ident(path); let llval = alloc_ty(bcx, var_ty, bcx.ident(ident)); diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 6c1a5003121..80b3455e9fa 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -93,7 +93,7 @@ local_data_key!(task_local_insn_key: ~[&'static str]) -pub fn with_insn_ctxt(blk: &fn(&[&'static str])) { +pub fn with_insn_ctxt(blk: |&[&'static str]|) { do local_data::get(task_local_insn_key) |c| { match c { Some(ctx) => blk(*ctx), @@ -787,10 +787,11 @@ pub fn cast_shift_const_rhs(op: ast::BinOp, } pub fn cast_shift_rhs(op: ast::BinOp, - lhs: ValueRef, rhs: ValueRef, - trunc: &fn(ValueRef, Type) -> ValueRef, - zext: &fn(ValueRef, Type) -> ValueRef) - -> ValueRef { + lhs: ValueRef, + rhs: ValueRef, + trunc: |ValueRef, Type| -> ValueRef, + zext: |ValueRef, Type| -> ValueRef) + -> ValueRef { // Shifts may have any size int on the rhs unsafe { if ast_util::is_shift_binop(op) { @@ -966,7 +967,7 @@ pub fn have_cached_lpad(bcx: @mut Block) -> bool { return res; } -pub fn in_lpad_scope_cx(bcx: @mut Block, f: &fn(si: &mut ScopeInfo)) { +pub fn in_lpad_scope_cx(bcx: @mut Block, f: |si: &mut ScopeInfo|) { let mut bcx = bcx; let mut cur_scope = bcx.scope; loop { @@ -1430,7 +1431,8 @@ pub fn leave_block(bcx: @mut Block, out_of: @mut Block) -> @mut Block { pub fn with_scope(bcx: @mut Block, opt_node_info: Option, name: &str, - f: &fn(@mut Block) -> @mut Block) -> @mut Block { + f: |@mut Block| -> @mut Block) + -> @mut Block { let _icx = push_ctxt("with_scope"); debug!("with_scope(bcx={}, opt_node_info={:?}, name={})", @@ -1448,7 +1450,8 @@ pub fn with_scope(bcx: @mut Block, pub fn with_scope_result(bcx: @mut Block, opt_node_info: Option, _name: &str, - f: &fn(@mut Block) -> Result) -> Result { + f: |@mut Block| -> Result) + -> Result { let _icx = push_ctxt("with_scope_result"); let scope = simple_block_scope(bcx.scope, opt_node_info); @@ -1462,9 +1465,11 @@ pub fn with_scope_result(bcx: @mut Block, rslt(out_bcx, val) } -pub fn with_scope_datumblock(bcx: @mut Block, opt_node_info: Option, - name: &str, f: &fn(@mut Block) -> datum::DatumBlock) - -> datum::DatumBlock { +pub fn with_scope_datumblock(bcx: @mut Block, + opt_node_info: Option, + name: &str, + f: |@mut Block| -> datum::DatumBlock) + -> datum::DatumBlock { use middle::trans::datum::DatumBlock; let _icx = push_ctxt("with_scope_result"); @@ -1474,7 +1479,7 @@ pub fn with_scope_datumblock(bcx: @mut Block, opt_node_info: Option, DatumBlock {bcx: leave_block(bcx, scope_cx), datum: datum} } -pub fn block_locals(b: &ast::Block, it: &fn(@ast::Local)) { +pub fn block_locals(b: &ast::Block, it: |@ast::Local|) { for s in b.stmts.iter() { match s.node { ast::StmtDecl(d, _) => { @@ -1488,7 +1493,10 @@ pub fn block_locals(b: &ast::Block, it: &fn(@ast::Local)) { } } -pub fn with_cond(bcx: @mut Block, val: ValueRef, f: &fn(@mut Block) -> @mut Block) -> @mut Block { +pub fn with_cond(bcx: @mut Block, + val: ValueRef, + f: |@mut Block| -> @mut Block) + -> @mut Block { let _icx = push_ctxt("with_cond"); let next_cx = base::sub_block(bcx, "next"); let cond_cx = base::sub_block(bcx, "cond"); @@ -1885,7 +1893,7 @@ pub fn trans_closure(ccx: @mut CrateContext, id: ast::NodeId, _attributes: &[ast::Attribute], output_type: ty::t, - maybe_load_env: &fn(@mut FunctionContext)) { + maybe_load_env: |@mut FunctionContext|) { ccx.stats.n_closures += 1; let _icx = push_ctxt("trans_closure"); set_uwtable(llfndecl); diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index 1e22c46dd5d..ebd7bb6937e 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -337,9 +337,9 @@ pub fn compute_abi_info(_ccx: &mut CrateContext, rty: Type, ret_def: bool) -> FnType { fn x86_64_ty(ty: Type, - is_mem_cls: &fn(cls: &[RegClass]) -> bool, - attr: Attribute) -> ArgType { - + is_mem_cls: |cls: &[RegClass]| -> bool, + attr: Attribute) + -> ArgType { if !ty.is_reg_ty() { let cls = classify_ty(ty); if is_mem_cls(cls) { diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index ecb53efbad7..d78311c8a39 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -600,7 +600,7 @@ pub fn trans_call_inner(in_cx: @mut Block, call_info: Option, callee_ty: ty::t, ret_ty: ty::t, - get_callee: &fn(@mut Block) -> Callee, + get_callee: |@mut Block| -> Callee, args: CallArgs, dest: Option, autoref_arg: AutorefArg) diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs index 9629615c64d..baccd9c7028 100644 --- a/src/librustc/middle/trans/closure.rs +++ b/src/librustc/middle/trans/closure.rs @@ -51,7 +51,7 @@ // }; // // Note that the closure is itself a rust_opaque_box. This is true -// even for ~fn and &fn, because we wish to keep binary compatibility +// even for ~fn and ||, because we wish to keep binary compatibility // between all kinds of closures. The allocation strategy for this // closure depends on the closure type. For a sendfn, the closure // (and the referenced type descriptors) will be allocated in the @@ -422,11 +422,12 @@ pub fn trans_expr_fn(bcx: @mut Block, return bcx; } -pub fn make_closure_glue( - cx: @mut Block, - v: ValueRef, - t: ty::t, - glue_fn: &fn(@mut Block, v: ValueRef, t: ty::t) -> @mut Block) -> @mut Block { +pub fn make_closure_glue(cx: @mut Block, + v: ValueRef, + t: ty::t, + glue_fn: |@mut Block, v: ValueRef, t: ty::t| + -> @mut Block) + -> @mut Block { let _icx = push_ctxt("closure::make_closure_glue"); let bcx = cx; let tcx = cx.tcx(); diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index c002584a7ff..48602534a3d 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -769,7 +769,9 @@ pub fn val_ty(v: ValueRef) -> Type { } } -pub fn in_scope_cx(cx: @mut Block, scope_id: Option, f: &fn(si: &mut ScopeInfo)) { +pub fn in_scope_cx(cx: @mut Block, + scope_id: Option, + f: |si: &mut ScopeInfo|) { let mut cur = cx; let mut cur_scope = cur.scope; loop { diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 01cf1022750..1806dee6c8f 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -524,7 +524,7 @@ pub fn get_element(&self, bcx: @mut Block, ty: ty::t, source: DatumCleanup, - gep: &fn(ValueRef) -> ValueRef) + gep: |ValueRef| -> ValueRef) -> Datum { let base_val = self.to_ref_llval(bcx); Datum { diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index d4b62953314..676af30b2ee 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -2274,9 +2274,9 @@ fn with_new_scope(cx: &mut CrateContext, scope_span: Span, scope_stack: &mut ~[ScopeStackEntry], scope_map: &mut HashMap, - inner_walk: &fn(&mut CrateContext, - &mut ~[ScopeStackEntry], - &mut HashMap)) { + inner_walk: |&mut CrateContext, + &mut ~[ScopeStackEntry], + &mut HashMap|) { // Create a new lexical scope and push it onto the stack let loc = cx.sess.codemap.lookup_char_pos(scope_span.lo); let file_metadata = file_metadata(cx, loc.file.name); diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index ddf9354ad38..9d8b539bac8 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -1151,10 +1151,12 @@ fn take_local(bcx: @mut Block, // The optional node ID here is the node ID of the path identifying the enum // variant in use. If none, this cannot possibly an enum variant (so, if it // is and `node_id_opt` is none, this function fails). -pub fn with_field_tys(tcx: ty::ctxt, - ty: ty::t, - node_id_opt: Option, - op: &fn(ty::Disr, (&[ty::field])) -> R) -> R { +pub fn with_field_tys( + tcx: ty::ctxt, + ty: ty::t, + node_id_opt: Option, + op: |ty::Disr, (&[ty::field])| -> R) + -> R { match ty::get(ty).sty { ty::ty_struct(did, ref substs) => { op(0, struct_fields(tcx, did, substs)) diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 7da80507df0..33036aab65b 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -510,11 +510,13 @@ unsafe fn build_wrap_fn(ccx: @mut CrateContext, // Array for the arguments we will pass to the rust function. let mut llrust_args = ~[]; let mut next_foreign_arg_counter: c_uint = 0; - let next_foreign_arg: &fn(pad: bool) -> c_uint = { - |pad: bool| { - next_foreign_arg_counter += if pad { 2 } else { 1 }; - next_foreign_arg_counter - 1 - } + let next_foreign_arg: |pad: bool| -> c_uint = |pad: bool| { + next_foreign_arg_counter += if pad { + 2 + } else { + 1 + }; + next_foreign_arg_counter - 1 }; // If there is an out pointer on the foreign function diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 0781f724d48..b1dc17a1239 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -121,7 +121,7 @@ pub fn visit(&mut self, ty_name: &str, args: &[ValueRef]) { pub fn bracketed(&mut self, bracket_name: &str, extra: &[ValueRef], - inner: &fn(&mut Reflector)) { + inner: |&mut Reflector|) { self.visit("enter_" + bracket_name, extra); inner(self); self.visit("leave_" + bracket_name, extra); diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 10a02e1e8be..2a8db56eec6 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -247,7 +247,7 @@ pub enum AutoRef { /// Convert from @[]/~[]/&[] to &&[] (or str) AutoBorrowVecRef(Region, ast::Mutability), - /// Convert from @fn()/~fn()/&fn() to &fn() + /// Convert from @fn()/~fn()/|| to || AutoBorrowFn(Region), /// Convert from T to *T @@ -651,7 +651,7 @@ pub enum sty { // "Fake" types, used for trans purposes ty_type, // type_desc* ty_opaque_box, // used by monomorphizer to represent any @ box - ty_opaque_closure_ptr(Sigil), // ptr to env for &fn, @fn, ~fn + ty_opaque_closure_ptr(Sigil), // ptr to env for ||, @fn, ~fn ty_unboxed_vec(mt), } @@ -1348,11 +1348,11 @@ pub fn mk_opaque_closure_ptr(cx: ctxt, sigil: ast::Sigil) -> t { pub fn mk_opaque_box(cx: ctxt) -> t { mk_t(cx, ty_opaque_box) } -pub fn walk_ty(ty: t, f: &fn(t)) { +pub fn walk_ty(ty: t, f: |t|) { maybe_walk_ty(ty, |t| { f(t); true }); } -pub fn maybe_walk_ty(ty: t, f: &fn(t) -> bool) { +pub fn maybe_walk_ty(ty: t, f: |t| -> bool) { if !f(ty) { return; } @@ -1382,25 +1382,19 @@ pub fn maybe_walk_ty(ty: t, f: &fn(t) -> bool) { } // Folds types from the bottom up. -pub fn fold_ty(cx: ctxt, t0: t, fldop: &fn(t) -> t) -> t { +pub fn fold_ty(cx: ctxt, t0: t, fldop: |t| -> t) -> t { let mut f = ty_fold::BottomUpFolder {tcx: cx, fldop: fldop}; f.fold_ty(t0) } -pub fn walk_regions_and_ty(cx: ctxt, - ty: t, - fldr: &fn(r: Region), - fldt: &fn(t: t)) +pub fn walk_regions_and_ty(cx: ctxt, ty: t, fldr: |r: Region|, fldt: |t: t|) -> t { ty_fold::RegionFolder::general(cx, |r| { fldr(r); r }, |t| { fldt(t); t }).fold_ty(ty) } -pub fn fold_regions(cx: ctxt, - ty: t, - fldr: &fn(r: Region) -> Region) - -> t { +pub fn fold_regions(cx: ctxt, ty: t, fldr: |r: Region| -> Region) -> t { ty_fold::RegionFolder::regions(cx, fldr).fold_ty(ty) } @@ -1886,7 +1880,7 @@ pub fn other_pointer(&self, bits: TypeContents) -> TypeContents { *self & TC::ReachesAll) } - pub fn union(v: &[T], f: &fn(&T) -> TypeContents) -> TypeContents { + pub fn union(v: &[T], f: |&T| -> TypeContents) -> TypeContents { v.iter().fold(TC::None, |tc, t| tc | f(t)) } @@ -2223,7 +2217,7 @@ fn kind_bounds_to_contents(cx: ctxt, fn each_inherited_builtin_bound(cx: ctxt, bounds: BuiltinBounds, traits: &[@TraitRef], - f: &fn(BuiltinBound)) { + f: |BuiltinBound|) { for bound in bounds.iter() { f(bound); } @@ -2351,10 +2345,8 @@ fn subtypes_require(cx: ctxt, seen: &mut ~[DefId], !subtypes_require(cx, &mut seen, r_ty, r_ty) } -pub fn type_structurally_contains(cx: ctxt, - ty: t, - test: &fn(x: &sty) -> bool) - -> bool { +pub fn type_structurally_contains(cx: ctxt, ty: t, test: |x: &sty| -> bool) + -> bool { let sty = &get(ty).sty; debug!("type_structurally_contains: {}", ::util::ppaux::ty_to_str(cx, ty)); @@ -2969,7 +2961,7 @@ fn borrow_obj(cx: ctxt, span: Span, r: Region, } impl AutoRef { - pub fn map_region(&self, f: &fn(Region) -> Region) -> AutoRef { + pub fn map_region(&self, f: |Region| -> Region) -> AutoRef { match *self { ty::AutoPtr(r, m) => ty::AutoPtr(f(r), m), ty::AutoBorrowVec(r, m) => ty::AutoBorrowVec(f(r), m), @@ -3525,11 +3517,10 @@ pub fn trait_ref_supertraits(cx: ctxt, trait_ref: &ty::TraitRef) -> ~[@TraitRef] } fn lookup_locally_or_in_crate_store( - descr: &str, - def_id: ast::DefId, - map: &mut HashMap, - load_external: &fn() -> V) -> V -{ + descr: &str, + def_id: ast::DefId, + map: &mut HashMap, + load_external: || -> V) -> V { /*! * Helper for looking things up in the various maps * that are populated during typeck::collect (e.g., @@ -3961,7 +3952,7 @@ pub fn lookup_trait_def(cx: ctxt, did: ast::DefId) -> @ty::TraitDef { /// Iterate over meta_items of a definition. // (This should really be an iterator, but that would require csearch and // decoder to use iterators instead of higher-order functions.) -pub fn each_attr(tcx: ctxt, did: DefId, f: &fn(@MetaItem) -> bool) -> bool { +pub fn each_attr(tcx: ctxt, did: DefId, f: |@MetaItem| -> bool) -> bool { if is_local(did) { match tcx.items.find(&did.node) { Some(&ast_map::node_item(@ast::item {attrs: ref attrs, _}, _)) => @@ -4341,7 +4332,8 @@ pub fn determine_inherited_purity(parent: (ast::purity, ast::NodeId), // list. pub fn each_bound_trait_and_supertraits(tcx: ctxt, bounds: &[@TraitRef], - f: &fn(@TraitRef) -> bool) -> bool { + f: |@TraitRef| -> bool) + -> bool { for &bound_trait_ref in bounds.iter() { let mut supertrait_set = HashMap::new(); let mut trait_refs = ~[]; diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 57581306b5d..7feb82788fc 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -33,7 +33,7 @@ * scopes and (b) the default region may change. To understand case (a), * consider something like: * - * type foo = { x: &a.int, y: &fn(&a.int) } + * type foo = { x: &a.int, y: |&a.int| } * * The type of `x` is an error because there is no region `a` in scope. * In the type of `y`, however, region `a` is considered a bound region @@ -290,13 +290,14 @@ fn ast_mt_to_mt( // Handle @, ~, and & being able to mean estrs and evecs. // If a_seq_ty is a str or a vec, make it an estr/evec. // Also handle first-class trait types. - fn mk_pointer( - this: &AC, - rscope: &RS, - a_seq_ty: &ast::mt, - vst: ty::vstore, - constr: &fn(ty::mt) -> ty::t) -> ty::t - { + fn mk_pointer( + this: &AC, + rscope: &RS, + a_seq_ty: &ast::mt, + vst: ty::vstore, + constr: |ty::mt| -> ty::t) + -> ty::t { let tcx = this.tcx(); debug!("mk_pointer(vst={:?})", vst); @@ -715,7 +716,7 @@ pub fn ty_of_closure( ty::ReStatic } ast::BorrowedSigil => { - // &fn() defaults as normal for an omitted lifetime: + // || defaults as normal for an omitted lifetime: opt_ast_region_to_region(this, rscope, span, opt_lifetime) } } diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs index 63f439e43e3..0785ba002aa 100644 --- a/src/librustc/middle/typeck/check/_match.rs +++ b/src/librustc/middle/typeck/check/_match.rs @@ -655,7 +655,7 @@ pub fn check_pointer_pat(pcx: &pat_ctxt, span: Span, expected: ty::t) { let fcx = pcx.fcx; - let check_inner: &fn(ty::mt) = |e_inner| { + let check_inner: |ty::mt| = |e_inner| { check_pat(pcx, inner, e_inner.ty); fcx.write_ty(pat_id, expected); }; diff --git a/src/librustc/middle/typeck/check/demand.rs b/src/librustc/middle/typeck/check/demand.rs index dc718bbef75..5973d791f52 100644 --- a/src/librustc/middle/typeck/check/demand.rs +++ b/src/librustc/middle/typeck/check/demand.rs @@ -31,9 +31,11 @@ pub fn subtype(fcx: @mut FnCtxt, sp: Span, expected: ty::t, actual: ty::t) { } pub fn suptype_with_fn(fcx: @mut FnCtxt, - sp: Span, b_is_expected: bool, - ty_a: ty::t, ty_b: ty::t, - handle_err: &fn(Span, ty::t, ty::t, &ty::type_err)) { + sp: Span, + b_is_expected: bool, + ty_a: ty::t, + ty_b: ty::t, + handle_err: |Span, ty::t, ty::t, &ty::type_err|) { // n.b.: order of actual, expected is reversed match infer::mk_subty(fcx.infcx(), b_is_expected, infer::Misc(sp), ty_b, ty_a) { diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 870b29882fd..8eaf3824ff4 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -483,12 +483,13 @@ fn push_inherent_candidates_from_bounds(&self, // Do a search through a list of bounds, using a callback to actually // create the candidates. - fn push_inherent_candidates_from_bounds_inner( - &self, - bounds: &[@TraitRef], - mk_cand: &fn(trait_ref: @TraitRef, m: @ty::Method, method_num: uint, - bound_num: uint) -> Candidate) { - + fn push_inherent_candidates_from_bounds_inner(&self, + bounds: &[@TraitRef], + mk_cand: |tr: @TraitRef, + m: @ty::Method, + method_num: uint, + bound_num: uint| + -> Candidate) { let tcx = self.tcx(); let mut next_bound_idx = 0; // count only trait bounds @@ -783,12 +784,12 @@ fn search_for_autoptrd_method(&self, self_ty: ty::t, autoderefs: uint) } fn search_for_some_kind_of_autorefd_method( - &self, - kind: &fn(Region, ast::Mutability) -> ty::AutoRef, - autoderefs: uint, - mutbls: &[ast::Mutability], - mk_autoref_ty: &fn(ast::Mutability, ty::Region) -> ty::t) - -> Option { + &self, + kind: |Region, ast::Mutability| -> ty::AutoRef, + autoderefs: uint, + mutbls: &[ast::Mutability], + mk_autoref_ty: |ast::Mutability, ty::Region| -> ty::t) + -> Option { // This is hokey. We should have mutability inference as a // variable. But for now, try &const, then &, then &mut: let region = diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index e46b92ae495..8d643ef2200 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -1194,7 +1194,7 @@ pub fn node_ty_substs(&self, id: ast::NodeId) -> ty::substs { pub fn opt_node_ty_substs(&self, id: ast::NodeId, - f: &fn(&ty::substs) -> bool) + f: |&ty::substs| -> bool) -> bool { match self.inh.node_type_substs.find(&id) { Some(s) => f(s), @@ -1257,8 +1257,7 @@ pub fn mk_subr(&self, infer::mk_subr(self.infcx(), a_is_expected, origin, sub, sup) } - pub fn with_region_lb(@mut self, lb: ast::NodeId, f: &fn() -> R) - -> R { + pub fn with_region_lb(@mut self, lb: ast::NodeId, f: || -> R) -> R { let old_region_lb = self.region_lb; self.region_lb = lb; let v = f(); @@ -1268,7 +1267,7 @@ pub fn with_region_lb(@mut self, lb: ast::NodeId, f: &fn() -> R) pub fn type_error_message(&self, sp: Span, - mk_msg: &fn(~str) -> ~str, + mk_msg: |~str| -> ~str, actual_ty: ty::t, err: Option<&ty::type_err>) { self.infcx().type_error_message(sp, mk_msg, actual_ty, err); @@ -1629,7 +1628,7 @@ fn check_type_parameter_positions_in_path(function_context: @mut FnCtxt, pub fn check_expr_with_unifier(fcx: @mut FnCtxt, expr: @ast::Expr, expected: Option, - unifier: &fn()) { + unifier: ||) { debug!(">> typechecking"); fn check_method_argument_types( @@ -2014,7 +2013,7 @@ fn lookup_op_method(fcx: @mut FnCtxt, args: ~[@ast::Expr], deref_args: DerefArgs, autoderef_receiver: AutoderefReceiverFlag, - unbound_method: &fn(), + unbound_method: ||, _expected_result: Option ) -> ty::t { @@ -2198,10 +2197,11 @@ fn check_user_unop(fcx: @mut FnCtxt, // through the `unpack` function. It there is no expected type or // resolution is not possible (e.g., no constraints yet present), just // returns `none`. - fn unpack_expected(fcx: @mut FnCtxt, - expected: Option, - unpack: &fn(&ty::sty) -> Option) - -> Option { + fn unpack_expected( + fcx: @mut FnCtxt, + expected: Option, + unpack: |&ty::sty| -> Option) + -> Option { match expected { Some(t) => { match resolve_type(fcx.infcx(), t, force_tvar) { diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs index ec11adbfa3d..ebdd4b5f48c 100644 --- a/src/librustc/middle/typeck/check/regionmanip.rs +++ b/src/librustc/middle/typeck/check/regionmanip.rs @@ -20,12 +20,11 @@ // Helper functions related to manipulating region types. pub fn replace_bound_regions_in_fn_sig( - tcx: ty::ctxt, - opt_self_ty: Option, - fn_sig: &ty::FnSig, - mapf: &fn(ty::BoundRegion) -> ty::Region) - -> (HashMap, Option, ty::FnSig) -{ + tcx: ty::ctxt, + opt_self_ty: Option, + fn_sig: &ty::FnSig, + mapf: |ty::BoundRegion| -> ty::Region) + -> (HashMap, Option, ty::FnSig) { debug!("replace_bound_regions_in_fn_sig(self_ty={}, fn_sig={})", opt_self_ty.repr(tcx), fn_sig.repr(tcx)); @@ -47,12 +46,10 @@ pub fn replace_bound_regions_in_fn_sig( (map, opt_self_ty, fn_sig) } -pub fn relate_nested_regions( - tcx: ty::ctxt, - opt_region: Option, - ty: ty::t, - relate_op: &fn(ty::Region, ty::Region)) -{ +pub fn relate_nested_regions(tcx: ty::ctxt, + opt_region: Option, + ty: ty::t, + relate_op: |ty::Region, ty::Region|) { /*! * This rather specialized function walks each region `r` that appear * in `ty` and invokes `relate_op(r_encl, r)` for each one. `r_encl` diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index bf00bee2709..78aa3f8fe40 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -451,7 +451,7 @@ pub fn check_implementation_coherence_of(&self, trait_def_id: DefId) { } } - pub fn iter_impls_of_trait(&self, trait_def_id: DefId, f: &fn(@Impl)) { + pub fn iter_impls_of_trait(&self, trait_def_id: DefId, f: |@Impl|) { match self.crate_context.tcx.trait_impls.find(&trait_def_id) { Some(impls) => { for &im in impls.iter() { diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs index e1f65f79e4f..e2ea0824400 100644 --- a/src/librustc/middle/typeck/infer/coercion.rs +++ b/src/librustc/middle/typeck/infer/coercion.rs @@ -161,9 +161,7 @@ pub fn subtype(&self, a: ty::t, b: ty::t) -> CoerceResult { } } - pub fn unpack_actual_value(&self, - a: ty::t, - f: &fn(&ty::sty) -> CoerceResult) + pub fn unpack_actual_value(&self, a: ty::t, f: |&ty::sty| -> CoerceResult) -> CoerceResult { match resolve_type(self.infcx, a, try_resolve_tvar_shallow) { Ok(t) => { diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index 9febef1c7c3..af7a23a4dfc 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -196,7 +196,7 @@ fn generalize_region(this: &Glb, // NB---I do not believe this algorithm computes // (necessarily) the GLB. As written it can // spuriously fail. In particular, if there is a case - // like: &fn(fn(&a)) and fn(fn(&b)), where a and b are + // like: |fn(&a)| and fn(fn(&b)), where a and b are // free, it will return fn(&c) where c = GLB(a,b). If // however this GLB is not defined, then the result is // an error, even though something like diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index eafc7e262f1..cde9dd135b3 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -442,12 +442,12 @@ pub fn resolve_region(cx: @mut InferCtxt, r: ty::Region, modes: uint) } trait then { - fn then(&self, f: &fn() -> Result) + fn then(&self, f: || -> Result) -> Result; } impl then for ures { - fn then(&self, f: &fn() -> Result) + fn then(&self, f: || -> Result) -> Result { self.and_then(|_i| f()) } @@ -467,11 +467,11 @@ fn to_ures(&self) -> ures { } trait CresCompare { - fn compare(&self, t: T, f: &fn() -> ty::type_err) -> cres; + fn compare(&self, t: T, f: || -> ty::type_err) -> cres; } impl CresCompare for cres { - fn compare(&self, t: T, f: &fn() -> ty::type_err) -> cres { + fn compare(&self, t: T, f: || -> ty::type_err) -> cres { do (*self).clone().and_then |s| { if s == t { (*self).clone() @@ -549,7 +549,7 @@ pub fn rollback_to(&mut self, snapshot: &Snapshot) { } /// Execute `f` and commit the bindings if successful - pub fn commit(@mut self, f: &fn() -> Result) -> Result { + pub fn commit(@mut self, f: || -> Result) -> Result { assert!(!self.in_snapshot()); debug!("commit()"); @@ -564,7 +564,7 @@ pub fn commit(@mut self, f: &fn() -> Result) -> Result { } /// Execute `f`, unroll bindings on failure - pub fn try(@mut self, f: &fn() -> Result) -> Result { + pub fn try(@mut self, f: || -> Result) -> Result { debug!("try()"); let snapshot = self.start_snapshot(); let r = f(); @@ -579,7 +579,7 @@ pub fn try(@mut self, f: &fn() -> Result) -> Result { } /// Execute `f` then unroll any bindings it creates - pub fn probe(@mut self, f: &fn() -> Result) -> Result { + pub fn probe(@mut self, f: || -> Result) -> Result { debug!("probe()"); do indent { let snapshot = self.start_snapshot(); @@ -721,7 +721,7 @@ pub fn resolve_type_vars_in_trait_ref_if_possible(@mut self, // errors. pub fn type_error_message_str(@mut self, sp: Span, - mk_msg: &fn(Option<~str>, ~str) -> ~str, + mk_msg: |Option<~str>, ~str| -> ~str, actual_ty: ~str, err: Option<&ty::type_err>) { self.type_error_message_str_with_expected(sp, mk_msg, None, actual_ty, err) @@ -729,9 +729,9 @@ pub fn type_error_message_str(@mut self, pub fn type_error_message_str_with_expected(@mut self, sp: Span, - mk_msg: - &fn(Option<~str>, ~str) -> - ~str, + mk_msg: |Option<~str>, + ~str| + -> ~str, expected_ty: Option, actual_ty: ~str, err: Option<&ty::type_err>) { @@ -760,7 +760,7 @@ pub fn type_error_message_str_with_expected(@mut self, pub fn type_error_message(@mut self, sp: Span, - mk_msg: &fn(~str) -> ~str, + mk_msg: |~str| -> ~str, actual_ty: ty::t, err: Option<&ty::type_err>) { let actual_ty = self.resolve_type_vars_if_possible(actual_ty); @@ -813,11 +813,10 @@ pub fn replace_bound_regions_with_fresh_regions(&mut self, } } -pub fn fold_regions_in_sig( - tcx: ty::ctxt, - fn_sig: &ty::FnSig, - fldr: &fn(r: ty::Region) -> ty::Region) -> ty::FnSig -{ +pub fn fold_regions_in_sig(tcx: ty::ctxt, + fn_sig: &ty::FnSig, + fldr: |r: ty::Region| -> ty::Region) + -> ty::FnSig { ty_fold::RegionFolder::regions(tcx, fldr).fold_sig(fn_sig) } diff --git a/src/librustc/middle/typeck/infer/region_inference/doc.rs b/src/librustc/middle/typeck/infer/region_inference/doc.rs index df6d5dc1b20..2b99a0a4f0e 100644 --- a/src/librustc/middle/typeck/infer/region_inference/doc.rs +++ b/src/librustc/middle/typeck/infer/region_inference/doc.rs @@ -389,7 +389,7 @@ fn foo() { // 'foo is the function body between functions with bound region parameters. Consider, for example, whether the following relation holds: - fn(&'a int) <: &fn(&'b int)? (Yes, a => b) + fn(&'a int) <: |&'b int|? (Yes, a => b) The answer is that of course it does. These two types are basically the same, except that in one we used the name `a` and one we used @@ -406,7 +406,7 @@ fn foo() { // 'foo is the function body `self` lifetime is defined somewhere outside and hence is not a lifetime parameter bound by the function type (it "appears free"): - fn(&'a int) <: &fn(&'self int)? (Yes, a => self) + fn(&'a int) <: |&'self int|? (Yes, a => self) This subtyping relation does in fact hold. To see why, you have to consider what subtyping means. One way to look at `T1 <: T2` is to @@ -423,7 +423,7 @@ fn(&'a int) <: &fn(&'self int)? (Yes, a => self) So, what if we reverse the order of the two function types, like this: - fn(&'self int) <: &fn(&'a int)? (No) + fn(&'self int) <: |&'a int|? (No) Does the subtyping relationship still hold? The answer of course is no. In this case, the function accepts *only the lifetime `&self`*, @@ -432,8 +432,8 @@ fn(&'a int) <: &fn(&'self int)? (Yes, a => self) What about these two examples: - fn(&'a int, &'b int) <: &fn(&'a int, &'a int)? (Yes) - fn(&'a int, &'a int) <: &fn(&'a int, &'b int)? (No) + fn(&'a int, &'b int) <: |&'a int, &'a int|? (Yes) + fn(&'a int, &'a int) <: |&'a int, &'b int|? (No) Here, it is true that functions which take two pointers with any two lifetimes can be treated as if they only accepted two pointers with @@ -457,12 +457,12 @@ fn(&'a int, &'a int) <: &fn(&'a int, &'b int)? (No) We'll start with the first example, which was: - 1. fn(&'a T) <: &fn(&'b T)? Yes: a -> b + 1. fn(&'a T) <: |&'b T|? Yes: a -> b After steps 1 and 2 of the algorithm we will have replaced the types like so: - 1. fn(&'A T) <: &fn(&'x T)? + 1. fn(&'A T) <: |&'x T|? Here the upper case `&A` indicates a *region variable*, that is, a region whose value is being inferred by the system. I also replaced @@ -491,12 +491,12 @@ fn(&'a int, &'a int) <: &fn(&'a int, &'b int)? (No) Now let's look first at the third example, which was: - 3. fn(&'self T) <: &fn(&'b T)? No! + 3. fn(&'self T) <: |&'b T|? No! After steps 1 and 2 of the algorithm we will have replaced the types like so: - 3. fn(&'self T) <: &fn(&'x T)? + 3. fn(&'self T) <: |&'x T|? This looks pretty much the same as before, except that on the LHS `&self` was not bound, and hence was left as-is and not replaced with @@ -511,7 +511,7 @@ fn(&'a int, &'a int) <: &fn(&'a int, &'b int)? (No) So far it has not been relevant. The purpose of that last step is to catch something like *this*: - fn() -> fn(&'a T) <: &fn() -> fn(&'b T)? No. + fn() -> fn(&'a T) <: || -> fn(&'b T)? No. Here the function types are the same but for where the binding occurs. The subtype returns a function that expects a value in precisely one @@ -525,15 +525,15 @@ fn() -> fn(&'a T) <: &fn() -> fn(&'b T)? No. We first replace the bound regions in the subtype (the supertype has no bound regions). This gives us: - fn() -> fn(&'A T) <: &fn() -> fn(&'b T)? + fn() -> fn(&'A T) <: || -> fn(&'b T)? Now we compare the return types, which are covariant, and hence we have: - fn(&'A T) <: &fn(&'b T)? + fn(&'A T) <: |&'b T|? Here we skolemize the bound region in the supertype to yield: - fn(&'A T) <: &fn(&'x T)? + fn(&'A T) <: |&'x T|? And then proceed to compare the argument types: @@ -550,7 +550,7 @@ fn() -> fn(&'a T) <: &fn() -> fn(&'b T)? No. `A` already existed at the point where the skolemization occurred. In the first example, you had two functions: - fn(&'a T) <: &fn(&'b T) + fn(&'a T) <: |&'b T| and hence `&A` and `&x` were created "together". In general, the intention of the skolemized names is that they are supposed to be diff --git a/src/librustc/middle/typeck/infer/region_inference/mod.rs b/src/librustc/middle/typeck/infer/region_inference/mod.rs index e613aa4ba28..ff4b20d369b 100644 --- a/src/librustc/middle/typeck/infer/region_inference/mod.rs +++ b/src/librustc/middle/typeck/infer/region_inference/mod.rs @@ -359,9 +359,9 @@ pub fn combine_vars(&mut self, a: Region, b: Region, origin: SubregionOrigin, - relate: &fn(this: &mut RegionVarBindings, - old_r: Region, - new_r: Region)) + relate: |this: &mut RegionVarBindings, + old_r: Region, + new_r: Region|) -> Region { let vars = TwoRegions { a: a, b: b }; match self.combine_map(t).find(&vars) { @@ -1254,7 +1254,7 @@ fn process_edges(this: &RegionVarBindings, fn iterate_until_fixed_point(&self, tag: &str, - body: &fn(constraint: &Constraint) -> bool) { + body: |constraint: &Constraint| -> bool) { let mut iteration = 0; let mut changed = true; while changed { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 63ddc9addc5..ed2b1d1db4b 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -282,15 +282,14 @@ pub fn no_params(t: ty::t) -> ty::ty_param_bounds_and_ty { } } -pub fn require_same_types( - tcx: ty::ctxt, - maybe_infcx: Option<@mut infer::InferCtxt>, - t1_is_expected: bool, - span: Span, - t1: ty::t, - t2: ty::t, - msg: &fn() -> ~str) -> bool { - +pub fn require_same_types(tcx: ty::ctxt, + maybe_infcx: Option<@mut infer::InferCtxt>, + t1_is_expected: bool, + span: Span, + t1: ty::t, + t2: ty::t, + msg: || -> ~str) + -> bool { let l_tcx; let l_infcx; match maybe_infcx { diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs index 1b435d11404..985bcaf96d1 100644 --- a/src/librustc/middle/typeck/variance.rs +++ b/src/librustc/middle/typeck/variance.rs @@ -150,8 +150,8 @@ impl ConvertTo for Object { ... } As a simple example, consider: enum Option { Some(A), None } - enum OptionalFn { Some(&fn(B)), None } - enum OptionalMap { Some(&fn(C) -> C), None } + enum OptionalFn { Some(|B|), None } + enum OptionalMap { Some(|C| -> C), None } Here, we will generate the constraints: diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index ecc53ae5f80..ffbea94c477 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -17,7 +17,7 @@ use std::hashmap::HashSet; use extra; -pub fn time(do_it: bool, what: &str, u: U, f: &fn(U) -> T) -> T { +pub fn time(do_it: bool, what: &str, u: U, f: |U| -> T) -> T { if !do_it { return f(u); } let start = extra::time::precise_time_s(); let rv = f(u); @@ -26,7 +26,7 @@ pub fn time(do_it: bool, what: &str, u: U, f: &fn(U) -> T) -> T { rv } -pub fn indent(op: &fn() -> R) -> R { +pub fn indent(op: || -> R) -> R { // Use in conjunction with the log post-processor like `src/etc/indenter` // to make debug output more readable. debug!(">>"); @@ -79,7 +79,7 @@ fn visit_expr(&mut self, e: @ast::Expr, _: ()) { // Takes a predicate p, returns true iff p is true for any subexpressions // of b -- skipping any inner loops (loop, while, loop_body) -pub fn loop_query(b: &ast::Block, p: &fn(&ast::Expr_) -> bool) -> bool { +pub fn loop_query(b: &ast::Block, p: |&ast::Expr_| -> bool) -> bool { let mut v = LoopQueryVisitor { p: p, flag: false, @@ -102,7 +102,7 @@ fn visit_expr(&mut self, e: @ast::Expr, _:()) { // Takes a predicate p, returns true iff p is true for any subexpressions // of b -- skipping any inner loops (loop, while, loop_body) -pub fn block_query(b: &ast::Block, p: &fn(@ast::Expr) -> bool) -> bool { +pub fn block_query(b: &ast::Block, p: |@ast::Expr| -> bool) -> bool { let mut v = BlockQueryVisitor { p: p, flag: false, diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index c5d7db465e6..0364eb890fb 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -286,7 +286,7 @@ pub fn vstore_ty_to_str(cx: ctxt, mt: &mt, vs: ty::vstore) -> ~str { } } -pub fn vec_map_to_str(ts: &[T], f: &fn(t: &T) -> ~str) -> ~str { +pub fn vec_map_to_str(ts: &[T], f: |t: &T| -> ~str) -> ~str { let tstrs = ts.map(f); format!("[{}]", tstrs.connect(", ")) }