From 492677ec1e4e66a57a2fce78962db2f89932dd74 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Tue, 19 Nov 2013 12:21:21 -0800 Subject: [PATCH] libsyntax: Change all uses of `&fn` to `||`. --- src/libsyntax/abi.rs | 4 +- src/libsyntax/ast_map.rs | 7 +- src/libsyntax/ast_util.rs | 6 +- src/libsyntax/diagnostic.rs | 8 +- src/libsyntax/ext/base.rs | 23 ++++-- src/libsyntax/ext/deriving/decodable.rs | 7 +- src/libsyntax/ext/deriving/generic.rs | 27 ++++--- src/libsyntax/ext/deriving/rand.rs | 6 +- src/libsyntax/fold.rs | 2 +- src/libsyntax/opt_vec.rs | 8 +- src/libsyntax/parse/lexer.rs | 16 ++-- src/libsyntax/parse/mod.rs | 21 ++---- src/libsyntax/parse/obsolete.rs | 2 +- src/libsyntax/parse/parser.rs | 99 +++++++++++++------------ src/libsyntax/print/pprust.rs | 12 ++- src/libsyntax/util/parser_testing.rs | 2 +- 16 files changed, 139 insertions(+), 111 deletions(-) diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs index 972d2f43e73..c2283bf1227 100644 --- a/src/libsyntax/abi.rs +++ b/src/libsyntax/abi.rs @@ -84,7 +84,7 @@ pub struct AbiSet { AbiData {abi: RustIntrinsic, name: "rust-intrinsic", abi_arch: RustArch}, ]; -fn each_abi(op: &fn(abi: Abi) -> bool) -> bool { +fn each_abi(op: |abi: Abi| -> bool) -> bool { /*! * * Iterates through each of the defined ABIs. @@ -201,7 +201,7 @@ pub fn add(&mut self, abi: Abi) { self.bits |= (1 << abi.index()); } - pub fn each(&self, op: &fn(abi: Abi) -> bool) -> bool { + pub fn each(&self, op: |abi: Abi| -> bool) -> bool { each_abi(|abi| !self.contains(abi) || op(abi)) } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index f3d7ac1804d..c5ad3714917 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -122,7 +122,7 @@ pub enum ast_node { } impl ast_node { - pub fn with_attrs(&self, f: &fn(Option<&[Attribute]>) -> T) -> T { + pub fn with_attrs(&self, f: |Option<&[Attribute]>| -> T) -> T { let attrs = match *self { node_item(i, _) => Some(i.attrs.as_slice()), node_foreign_item(fi, _, _, _) => Some(fi.attrs.as_slice()), @@ -480,9 +480,8 @@ pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str { } } -pub fn node_item_query(items: map, id: NodeId, - query: &fn(@item) -> Result, - error_msg: ~str) -> Result { +pub fn node_item_query(items: map, id: NodeId, query: |@item| -> Result, error_msg: ~str) + -> Result { match items.find(&id) { Some(&node_item(it, _)) => query(it), _ => fail!("{}", error_msg) diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index fb50a890c43..a49109911de 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -636,7 +636,7 @@ pub fn is_item_impl(item: @ast::item) -> bool { } } -pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool { +pub fn walk_pat(pat: @Pat, it: |@Pat| -> bool) -> bool { if !it(pat) { return false; } @@ -665,7 +665,7 @@ pub fn walk_pat(pat: @Pat, it: &fn(@Pat) -> bool) -> bool { } pub trait EachViewItem { - fn each_view_item(&self, f: &fn(&ast::view_item) -> bool) -> bool; + fn each_view_item(&self, f: |&ast::view_item| -> bool) -> bool; } struct EachViewItemData<'self> { @@ -679,7 +679,7 @@ fn visit_view_item(&mut self, view_item: &ast::view_item, _: ()) { } impl EachViewItem for ast::Crate { - fn each_view_item(&self, f: &fn(&ast::view_item) -> bool) -> bool { + fn each_view_item(&self, f: |&ast::view_item| -> bool) -> bool { let mut visit = EachViewItemData { callback: f, }; diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 0565399bdf4..15b82730629 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -347,9 +347,11 @@ fn print_macro_backtrace(cm: @codemap::CodeMap, sp: Span) { } } -pub fn expect(diag: @mut span_handler, - opt: Option, - msg: &fn() -> ~str) -> T { +pub fn expect( + diag: @mut span_handler, + opt: Option, + msg: || -> ~str) + -> T { match opt { Some(ref t) => (*t).clone(), None => diag.handler().bug(msg()), diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 7ce73a4afef..448f8ee88f9 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -559,11 +559,11 @@ pub fn contains_key (&self, key: &K) -> bool { // should each_key and each_value operate on shadowed // names? I think not. // delaying implementing this.... - pub fn each_key (&self, _f: &fn (&K)->bool) { + pub fn each_key (&self, _f: |&K| -> bool) { fail!("unimplemented 2013-02-15T10:01"); } - pub fn each_value (&self, _f: &fn (&V) -> bool) { + pub fn each_value (&self, _f: |&V| -> bool) { fail!("unimplemented 2013-02-15T10:02"); } @@ -601,7 +601,11 @@ pub fn insert (&mut self, key: K, ext: @V) -> bool { // ... there are definitely some opportunities for abstraction // here that I'm ignoring. (e.g., manufacturing a predicate on // the maps in the chain, and using an abstract "find". - pub fn insert_into_frame(&mut self, key: K, ext: @V, n: K, pred: &fn(&@V)->bool) { + pub fn insert_into_frame(&mut self, + key: K, + ext: @V, + n: K, + pred: |&@V| -> bool) { match *self { BaseMapChain (~ref mut map) => { if satisfies_pred(map,&n,pred) { @@ -622,10 +626,12 @@ pub fn insert_into_frame(&mut self, key: K, ext: @V, n: K, pred: &fn(&@V)->bool) } // returns true if the binding for 'n' satisfies 'pred' in 'map' -fn satisfies_pred(map : &mut HashMap, - n: &K, - pred: &fn(&V)->bool) - -> bool { +fn satisfies_pred( + map: &mut HashMap, + n: &K, + pred: |&V| -> bool) + -> bool { match map.find(n) { Some(ref v) => (pred(*v)), None => false @@ -637,7 +643,8 @@ mod test { use super::MapChain; use std::hashmap::HashMap; - #[test] fn testenv () { + #[test] + fn testenv() { let mut a = HashMap::new(); a.insert (@"abc",@15); let m = MapChain::new(~a); diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index 3f745d64a7b..2f9222ccb56 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -124,9 +124,12 @@ fn decodable_substructure(cx: @ExtCtxt, span: Span, /// Create a decoder for a single enum variant/struct: /// - `outer_pat_ident` is the name of this enum variant/struct /// - `getarg` should retrieve the `uint`-th field with name `@str`. -fn decode_static_fields(cx: @ExtCtxt, outer_span: Span, outer_pat_ident: Ident, +fn decode_static_fields(cx: @ExtCtxt, + outer_span: Span, + outer_pat_ident: Ident, fields: &StaticFields, - getarg: &fn(Span, @str, uint) -> @Expr) -> @Expr { + getarg: |Span, @str, uint| -> @Expr) + -> @Expr { match *fields { Unnamed(ref fields) => { if fields.is_empty() { diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index aa83b7656a6..23dc38fdc31 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -1064,14 +1064,13 @@ fn create_enum_variant_pattern(cx: @ExtCtxt, left-to-right (`true`) or right-to-left (`false`). */ pub fn cs_fold(use_foldl: bool, - f: &fn(@ExtCtxt, Span, - old: @Expr, - self_f: @Expr, - other_fs: &[@Expr]) -> @Expr, + f: |@ExtCtxt, Span, @Expr, @Expr, &[@Expr]| -> @Expr, base: @Expr, enum_nonmatch_f: EnumNonMatchFunc, - cx: @ExtCtxt, trait_span: Span, - substructure: &Substructure) -> @Expr { + cx: @ExtCtxt, + trait_span: Span, + substructure: &Substructure) + -> @Expr { match *substructure.fields { EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { if use_foldl { @@ -1104,10 +1103,12 @@ pub fn cs_fold(use_foldl: bool, ~~~ */ #[inline] -pub fn cs_same_method(f: &fn(@ExtCtxt, Span, ~[@Expr]) -> @Expr, +pub fn cs_same_method(f: |@ExtCtxt, Span, ~[@Expr]| -> @Expr, enum_nonmatch_f: EnumNonMatchFunc, - cx: @ExtCtxt, trait_span: Span, - substructure: &Substructure) -> @Expr { + cx: @ExtCtxt, + trait_span: Span, + substructure: &Substructure) + -> @Expr { match *substructure.fields { EnumMatching(_, _, ref all_fields) | Struct(ref all_fields) => { // call self_n.method(other_1_n, other_2_n, ...) @@ -1136,11 +1137,13 @@ pub fn cs_same_method(f: &fn(@ExtCtxt, Span, ~[@Expr]) -> @Expr, */ #[inline] pub fn cs_same_method_fold(use_foldl: bool, - f: &fn(@ExtCtxt, Span, @Expr, @Expr) -> @Expr, + f: |@ExtCtxt, Span, @Expr, @Expr| -> @Expr, base: @Expr, enum_nonmatch_f: EnumNonMatchFunc, - cx: @ExtCtxt, trait_span: Span, - substructure: &Substructure) -> @Expr { + cx: @ExtCtxt, + trait_span: Span, + substructure: &Substructure) + -> @Expr { cs_same_method( |cx, span, vals| { if use_foldl { diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs index 2a16d0b025d..1877a6eb85b 100644 --- a/src/libsyntax/ext/deriving/rand.rs +++ b/src/libsyntax/ext/deriving/rand.rs @@ -128,10 +128,12 @@ fn rand_substructure(cx: @ExtCtxt, span: Span, substr: &Substructure) -> @Expr { _ => cx.bug("Non-static method in `deriving(Rand)`") }; - fn rand_thing(cx: @ExtCtxt, span: Span, + fn rand_thing(cx: @ExtCtxt, + span: Span, ctor_ident: Ident, summary: &StaticFields, - rand_call: &fn(Span) -> @Expr) -> @Expr { + rand_call: |Span| -> @Expr) + -> @Expr { match *summary { Unnamed(ref fields) => { if fields.is_empty() { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index bd99f58cde9..62592650416 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -381,7 +381,7 @@ fn fold_mac(&self, macro: &mac) -> mac { } } - fn map_exprs(&self, f: &fn(@Expr) -> @Expr, es: &[@Expr]) -> ~[@Expr] { + fn map_exprs(&self, f: |@Expr| -> @Expr, es: &[@Expr]) -> ~[@Expr] { es.map(|x| f(*x)) } diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs index 4d39d4df72f..3a0b7c6adc4 100644 --- a/src/libsyntax/opt_vec.rs +++ b/src/libsyntax/opt_vec.rs @@ -50,14 +50,14 @@ pub fn push(&mut self, t: T) { *self = Vec(~[t]); } - pub fn map(&self, op: &fn(&T) -> U) -> OptVec { + pub fn map(&self, op: |&T| -> U) -> OptVec { match *self { Empty => Empty, Vec(ref v) => Vec(v.map(op)) } } - pub fn map_move(self, op: &fn(T) -> U) -> OptVec { + pub fn map_move(self, op: |T| -> U) -> OptVec { match self { Empty => Empty, Vec(v) => Vec(v.move_iter().map(op).collect()) @@ -91,11 +91,11 @@ pub fn iter<'r>(&'r self) -> OptVecIterator<'r, T> { } #[inline] - pub fn map_to_vec(&self, op: &fn(&T) -> B) -> ~[B] { + pub fn map_to_vec(&self, op: |&T| -> B) -> ~[B] { self.iter().map(op).collect() } - pub fn mapi_to_vec(&self, op: &fn(uint, &T) -> B) -> ~[B] { + pub fn mapi_to_vec(&self, op: |uint, &T| -> B) -> ~[B] { let mut index = 0; self.map_to_vec(|a| { let i = index; diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index 06a2c557e42..26de9215dbf 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -216,16 +216,22 @@ fn byte_offset(rdr: &StringReader, pos: BytePos) -> BytePos { /// Calls `f` with a string slice of the source text spanning from `start` /// up to but excluding `rdr.last_pos`, meaning the slice does not include /// the character `rdr.curr`. -pub fn with_str_from(rdr: @mut StringReader, start: BytePos, f: &fn(s: &str) -> T) -> T { +pub fn with_str_from( + rdr: @mut StringReader, + start: BytePos, + f: |s: &str| -> T) + -> T { with_str_from_to(rdr, start, rdr.last_pos, f) } /// Calls `f` with astring slice of the source text spanning from `start` /// up to but excluding `end`. -fn with_str_from_to(rdr: @mut StringReader, - start: BytePos, - end: BytePos, - f: &fn(s: &str) -> T) -> T { +fn with_str_from_to( + rdr: @mut StringReader, + start: BytePos, + end: BytePos, + f: |s: &str| -> T) + -> T { f(rdr.src.slice( byte_offset(rdr, start).to_uint(), byte_offset(rdr, end).to_uint())) diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 0e9a529f950..947f7a7fc29 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -177,19 +177,14 @@ pub fn parse_tts_from_source_str( // consumed all of the input before returning the function's // result. pub fn parse_from_source_str( - f: &fn(&Parser) -> T, - name: @str, ss: codemap::FileSubstr, - source: @str, - cfg: ast::CrateConfig, - sess: @mut ParseSess -) -> T { - let p = new_parser_from_source_substr( - sess, - cfg, - name, - ss, - source - ); + f: |&Parser| -> T, + name: @str, + ss: codemap::FileSubstr, + source: @str, + cfg: ast::CrateConfig, + sess: @mut ParseSess) + -> T { + let p = new_parser_from_source_substr(sess, cfg, name, ss, source); let r = f(&p); if !p.reader.is_eof() { p.reader.fatal(~"expected end-of-string"); diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 189cc8e827c..3adedf76eb8 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -82,7 +82,7 @@ fn obsolete(&self, sp: Span, kind: ObsoleteSyntax) { ), ObsoleteBareFnType => ( "bare function type", - "use `&fn` or `extern fn` instead" + "use `|A| -> B` or `extern fn(A) -> B` instead" ), ObsoleteNamedExternModule => ( "named external module", diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 2ea6878f4a3..6c2df4ad314 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -581,10 +581,8 @@ fn expect_or(&self) { } // Parse a sequence bracketed by `|` and `|`, stopping before the `|`. - fn parse_seq_to_before_or(&self, - sep: &token::Token, - f: &fn(&Parser) -> T) - -> ~[T] { + fn parse_seq_to_before_or(&self, sep: &token::Token, f: |&Parser| -> T) + -> ~[T] { let mut first = true; let mut vector = ~[]; while *self.token != token::BINOP(token::OR) && @@ -619,10 +617,11 @@ pub fn expect_gt(&self) { // parse a sequence bracketed by '<' and '>', stopping // before the '>'. - pub fn parse_seq_to_before_gt(&self, - sep: Option, - f: &fn(&Parser) -> T) - -> OptVec { + pub fn parse_seq_to_before_gt( + &self, + sep: Option, + f: |&Parser| -> T) + -> OptVec { let mut first = true; let mut v = opt_vec::Empty; while *self.token != token::GT @@ -639,10 +638,11 @@ pub fn parse_seq_to_before_gt(&self, return v; } - pub fn parse_seq_to_gt(&self, - sep: Option, - f: &fn(&Parser) -> T) - -> OptVec { + pub fn parse_seq_to_gt( + &self, + sep: Option, + f: |&Parser| -> T) + -> OptVec { let v = self.parse_seq_to_before_gt(sep, f); self.expect_gt(); return v; @@ -651,11 +651,12 @@ pub fn parse_seq_to_gt(&self, // parse a sequence, including the closing delimiter. The function // f must consume tokens until reaching the next separator or // closing bracket. - pub fn parse_seq_to_end(&self, - ket: &token::Token, - sep: SeqSep, - f: &fn(&Parser) -> T) - -> ~[T] { + pub fn parse_seq_to_end( + &self, + ket: &token::Token, + sep: SeqSep, + f: |&Parser| -> T) + -> ~[T] { let val = self.parse_seq_to_before_end(ket, sep, f); self.bump(); val @@ -664,11 +665,12 @@ pub fn parse_seq_to_end(&self, // parse a sequence, not including the closing delimiter. The function // f must consume tokens until reaching the next separator or // closing bracket. - pub fn parse_seq_to_before_end(&self, - ket: &token::Token, - sep: SeqSep, - f: &fn(&Parser) -> T) - -> ~[T] { + pub fn parse_seq_to_before_end( + &self, + ket: &token::Token, + sep: SeqSep, + f: |&Parser| -> T) + -> ~[T] { let mut first: bool = true; let mut v: ~[T] = ~[]; while *self.token != *ket { @@ -688,12 +690,13 @@ pub fn parse_seq_to_before_end(&self, // parse a sequence, including the closing delimiter. The function // f must consume tokens until reaching the next separator or // closing bracket. - pub fn parse_unspanned_seq(&self, - bra: &token::Token, - ket: &token::Token, - sep: SeqSep, - f: &fn(&Parser) -> T) - -> ~[T] { + pub fn parse_unspanned_seq( + &self, + bra: &token::Token, + ket: &token::Token, + sep: SeqSep, + f: |&Parser| -> T) + -> ~[T] { self.expect(bra); let result = self.parse_seq_to_before_end(ket, sep, f); self.bump(); @@ -702,12 +705,13 @@ pub fn parse_unspanned_seq(&self, // NB: Do not use this function unless you actually plan to place the // spanned list in the AST. - pub fn parse_seq(&self, - bra: &token::Token, - ket: &token::Token, - sep: SeqSep, - f: &fn(&Parser) -> T) - -> Spanned<~[T]> { + pub fn parse_seq( + &self, + bra: &token::Token, + ket: &token::Token, + sep: SeqSep, + f: |&Parser| -> T) + -> Spanned<~[T]> { let lo = self.span.lo; self.expect(bra); let result = self.parse_seq_to_before_end(ket, sep, f); @@ -765,8 +769,8 @@ pub fn buffer_length(&self) -> int { } return (4 - *self.buffer_start) + *self.buffer_end; } - pub fn look_ahead(&self, distance: uint, f: &fn(&token::Token) -> R) - -> R { + pub fn look_ahead(&self, distance: uint, f: |&token::Token| -> R) + -> R { let dist = distance as int; while self.buffer_length() < dist { self.buffer[*self.buffer_end] = self.reader.next_token(); @@ -1272,7 +1276,8 @@ pub fn parse_ty(&self, _: bool) -> Ty { // parse the type following a @ or a ~ pub fn parse_box_or_uniq_pointee(&self, sigil: ast::Sigil, - ctor: &fn(v: mt) -> ty_) -> ty_ { + ctor: |v: mt| -> ty_) + -> ty_ { // ~'foo fn() or ~fn() are parsed directly as obsolete fn types: match *self.token { token::LIFETIME(*) => { @@ -2467,8 +2472,8 @@ pub fn parse_lambda_expr(&self) -> @Expr { // this is used both in parsing a lambda expr // and in parsing a block expr as e.g. in for... pub fn parse_lambda_expr_(&self, - parse_decl: &fn() -> fn_decl, - parse_body: &fn() -> @Expr) + parse_decl: || -> fn_decl, + parse_body: || -> @Expr) -> @Expr { let lo = self.last_span.lo; let decl = parse_decl(); @@ -2513,10 +2518,11 @@ pub fn parse_for_expr(&self, opt_ident: Option) -> @Expr { // parse a 'for' or 'do'. // the 'for' and 'do' expressions parse as calls, but look like // function calls followed by a closure expression. - pub fn parse_sugary_call_expr(&self, lo: BytePos, + pub fn parse_sugary_call_expr(&self, + lo: BytePos, keyword: ~str, sugar: CallSugar, - ctor: &fn(v: @Expr) -> Expr_) + ctor: |v: @Expr| -> Expr_) -> @Expr { // Parse the callee `foo` in // for foo || { @@ -3611,11 +3617,12 @@ fn expect_self_ident(&self) { // parse the argument list and result type of a function // that may have a self type. - fn parse_fn_decl_with_self(&self, parse_arg_fn: &fn(&Parser) -> arg) - -> (explicit_self, fn_decl) { - - fn maybe_parse_explicit_self(cnstr: &fn(v: Mutability) -> ast::explicit_self_, - p: &Parser) -> ast::explicit_self_ { + fn parse_fn_decl_with_self(&self, parse_arg_fn: |&Parser| -> arg) + -> (explicit_self, fn_decl) { + fn maybe_parse_explicit_self(cnstr: |v: Mutability| -> + ast::explicit_self_, + p: &Parser) + -> ast::explicit_self_ { // We need to make sure it isn't a type if p.look_ahead(1, |t| token::is_keyword(keywords::Self, t)) || ((p.look_ahead(1, |t| token::is_keyword(keywords::Const, t)) || diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 68af73d4a01..8d31133e9e2 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -331,7 +331,7 @@ pub fn synth_comment(s: @ps, text: ~str) { word(s.s, "*/"); } -pub fn commasep(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T)) { +pub fn commasep(s: @ps, b: breaks, elts: &[T], op: |@ps, &T|) { box(s, 0u, b); let mut first = true; for elt in elts.iter() { @@ -342,8 +342,12 @@ pub fn commasep(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T)) { } -pub fn commasep_cmnt(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T), - get_span: &fn(&T) -> codemap::Span) { +pub fn commasep_cmnt( + s: @ps, + b: breaks, + elts: &[T], + op: |@ps, &T|, + get_span: |&T| -> codemap::Span) { box(s, 0u, b); let len = elts.len(); let mut i = 0u; @@ -2289,7 +2293,7 @@ pub fn print_string(s: @ps, st: &str, style: ast::StrStyle) { word(s.s, st); } -pub fn to_str(t: &T, f: &fn(@ps, &T), intr: @ident_interner) -> ~str { +pub fn to_str(t: &T, f: |@ps, &T|, intr: @ident_interner) -> ~str { let wr = @mut MemWriter::new(); let s = rust_printer(wr as @mut io::Writer, intr); f(s, t); diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs index 59a6f0adeb4..3a2a8b10c96 100644 --- a/src/libsyntax/util/parser_testing.rs +++ b/src/libsyntax/util/parser_testing.rs @@ -39,7 +39,7 @@ pub fn string_to_parser(source_str: @str) -> Parser { p } -fn with_error_checking_parse(s: @str, f: &fn(&mut Parser) -> T) -> T { +fn with_error_checking_parse(s: @str, f: |&mut Parser| -> T) -> T { let mut p = string_to_parser(s); let x = f(&mut p); p.abort_if_errors(); -- GitLab