From ba3eebd41db384c2a46535e8db8c7b2337d55f0b Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Sun, 23 Sep 2012 04:39:27 -0700 Subject: [PATCH] Make it illegal to use modes in a fn signature with providing an explicit variable name. (Step one to changing the defaults) First step to #3535 --- src/libcore/at_vec.rs | 7 +-- src/libcore/dvec.rs | 6 +-- src/libcore/io.rs | 6 +-- src/libcore/iter.rs | 6 +-- src/libcore/option.rs | 6 +-- src/libcore/pipes.rs | 4 +- src/libcore/str.rs | 3 +- src/libcore/task.rs | 12 ++--- src/libcore/task/local_data.rs | 2 +- src/libcore/task/spawn.rs | 2 +- src/libcore/vec.rs | 15 +++--- src/libstd/arc.rs | 2 +- src/libstd/bitv.rs | 2 +- src/libstd/map.rs | 2 +- src/libstd/sync.rs | 2 +- src/libsyntax/ast.rs | 2 +- src/libsyntax/ext/auto_serialize.rs | 8 ++-- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/pipes/ast_builder.rs | 4 +- src/libsyntax/fold.rs | 46 +++++++++---------- src/libsyntax/parse/obsolete.rs | 8 +++- src/libsyntax/parse/parser.rs | 16 +++++-- src/test/bench/pingpong.rs | 2 +- .../bench/task-perf-word-count-generic.rs | 4 +- src/test/compile-fail/arg-style-mismatch.rs | 2 +- src/test/compile-fail/issue-2766-a.rs | 2 +- .../class-impl-very-parameterized-trait.rs | 6 +-- src/test/run-pass/fixed-point-bind-box.rs | 2 +- src/test/run-pass/fixed-point-bind-unique.rs | 2 +- src/test/run-pass/fn-bare-assign.rs | 2 +- src/test/run-pass/generic-temporary.rs | 2 +- src/test/run-pass/issue-2185.rs | 4 +- src/test/run-pass/pipe-bank-proto.rs | 2 +- src/test/run-pass/sendfn-generic-fn.rs | 2 +- src/test/run-pass/static-method-test.rs | 8 ++-- 35 files changed, 111 insertions(+), 92 deletions(-) diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 7864983bde26..1b90e25fdc1c 100644 --- a/src/libcore/at_vec.rs +++ b/src/libcore/at_vec.rs @@ -50,7 +50,8 @@ pure fn capacity(&&v: @[const T]) -> uint { * onto the vector being constructed. */ #[inline(always)] -pure fn build_sized(size: uint, builder: fn(push: pure fn(+A))) -> @[A] { +pure fn build_sized(size: uint, + builder: fn(push: pure fn(+v: A))) -> @[A] { let mut vec = @[]; unsafe { raw::reserve(vec, size); } builder(|+x| unsafe { raw::push(vec, move x) }); @@ -68,7 +69,7 @@ pure fn build_sized(size: uint, builder: fn(push: pure fn(+A))) -> @[A] { * onto the vector being constructed. */ #[inline(always)] -pure fn build(builder: fn(push: pure fn(+A))) -> @[A] { +pure fn build(builder: fn(push: pure fn(+v: A))) -> @[A] { build_sized(4, builder) } @@ -86,7 +87,7 @@ pure fn build(builder: fn(push: pure fn(+A))) -> @[A] { */ #[inline(always)] pure fn build_sized_opt(size: Option, - builder: fn(push: pure fn(+A))) -> @[A] { + builder: fn(push: pure fn(+v: A))) -> @[A] { build_sized(size.get_default(4), builder) } diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs index 210ddd483e64..82767112b395 100644 --- a/src/libcore/dvec.rs +++ b/src/libcore/dvec.rs @@ -93,7 +93,7 @@ priv impl DVec { } #[inline(always)] - fn check_out(f: fn(-~[A]) -> B) -> B { + fn check_out(f: fn(-v: ~[A]) -> B) -> B { unsafe { let mut data = cast::reinterpret_cast(&null::<()>()); data <-> self.data; @@ -126,7 +126,7 @@ impl DVec { * and return a new vector to replace it with. */ #[inline(always)] - fn swap(f: fn(-~[A]) -> ~[A]) { + fn swap(f: fn(-v: ~[A]) -> ~[A]) { self.check_out(|v| self.give_back(f(move v))) } @@ -136,7 +136,7 @@ impl DVec { * and return a new vector to replace it with. */ #[inline(always)] - fn swap_mut(f: fn(-~[mut A]) -> ~[mut A]) { + fn swap_mut(f: fn(-v: ~[mut A]) -> ~[mut A]) { do self.swap |v| { vec::from_mut(f(vec::to_mut(move v))) } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index c4fd5678ac28..bc7f2c9e6664 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -827,7 +827,7 @@ mod fsync { // FIXME (#2004) find better way to create resources within lifetime of // outer res fn FILE_res_sync(&&file: FILERes, opt_level: Option, - blk: fn(&&Res<*libc::FILE>)) { + blk: fn(&&v: Res<*libc::FILE>)) { blk(Res({ val: file.f, opt_level: opt_level, fsync_fn: fn@(&&file: *libc::FILE, l: Level) -> int { @@ -838,7 +838,7 @@ mod fsync { // fsync fd after executing blk fn fd_res_sync(&&fd: FdRes, opt_level: Option, - blk: fn(&&Res)) { + blk: fn(&&v: Res)) { blk(Res({ val: fd.fd, opt_level: opt_level, fsync_fn: fn@(&&fd: fd_t, l: Level) -> int { @@ -852,7 +852,7 @@ mod fsync { // Call o.fsync after executing blk fn obj_sync(&&o: FSyncable, opt_level: Option, - blk: fn(&&Res)) { + blk: fn(&&v: Res)) { blk(Res({ val: o, opt_level: opt_level, fsync_fn: fn@(&&o: FSyncable, l: Level) -> int { diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index c22d3c6e6645..8af4ce3d0b1b 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -63,7 +63,7 @@ trait Buildable { * onto the sequence being constructed. */ static pure fn build_sized(size: uint, - builder: fn(push: pure fn(+A))) -> self; + builder: fn(push: pure fn(+v: A))) -> self; } pure fn eachi>(self: IA, blk: fn(uint, v: &A) -> bool) { @@ -223,7 +223,7 @@ pure fn find>(self: IA, * onto the sequence being constructed. */ #[inline(always)] -pure fn build>(builder: fn(push: pure fn(+A))) -> B { +pure fn build>(builder: fn(push: pure fn(+v: A))) -> B { build_sized(4, builder) } @@ -243,7 +243,7 @@ pure fn build>(builder: fn(push: pure fn(+A))) -> B { #[inline(always)] pure fn build_sized_opt>( size: Option, - builder: fn(push: pure fn(+A))) -> B { + builder: fn(push: pure fn(+v: A))) -> B { build_sized(size.get_default(4), builder) } diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 0844332672a6..cadafc81013d 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -69,7 +69,7 @@ pure fn map_ref(opt: &Option, f: fn(x: &T) -> U) -> Option { match *opt { Some(ref x) => Some(f(x)), None => None } } -pure fn map_consume(+opt: Option, f: fn(+T) -> U) -> Option { +pure fn map_consume(+opt: Option, f: fn(+v: T) -> U) -> Option { /*! * As `map`, but consumes the option and gives `f` ownership to avoid * copying. @@ -107,7 +107,7 @@ pure fn or(+opta: Option, +optb: Option) -> Option { } #[inline(always)] -pure fn while_some(+x: Option, blk: fn(+T) -> Option) { +pure fn while_some(+x: Option, blk: fn(+v: T) -> Option) { //! Applies a function zero or more times until the result is none. let mut opt <- x; @@ -248,7 +248,7 @@ impl Option { */ pure fn expect(reason: ~str) -> T { expect(self, reason) } /// Applies a function zero or more times until the result is none. - pure fn while_some(blk: fn(+T) -> Option) { while_some(self, blk) } + pure fn while_some(blk: fn(+v: T) -> Option) { while_some(self, blk) } } #[cfg(stage0)] diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index 5b9770805735..ecc1e4e8a632 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -889,7 +889,7 @@ endpoint is passed to the new task. fn spawn_service( init: extern fn() -> (SendPacketBuffered, RecvPacketBuffered), - +service: fn~(+RecvPacketBuffered)) + +service: fn~(+v: RecvPacketBuffered)) -> SendPacketBuffered { let (client, server) = init(); @@ -913,7 +913,7 @@ receive state. fn spawn_service_recv( init: extern fn() -> (RecvPacketBuffered, SendPacketBuffered), - +service: fn~(+SendPacketBuffered)) + +service: fn~(+v: SendPacketBuffered)) -> RecvPacketBuffered { let (client, server) = init(); diff --git a/src/libcore/str.rs b/src/libcore/str.rs index bc0a321360ef..ab4e77895b94 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -2109,7 +2109,8 @@ mod raw { unsafe fn from_byte(u: u8) -> ~str { raw::from_bytes([u]) } /// Form a slice from a *u8 buffer of the given length without copying. - unsafe fn buf_as_slice(buf: *u8, len: uint, f: fn(&& &str) -> T) -> T { + unsafe fn buf_as_slice(buf: *u8, len: uint, + f: fn(&&v: &str) -> T) -> T { let v = (buf, len + 1); assert is_utf8(::cast::reinterpret_cast(&v)); f(::cast::transmute(move v)) diff --git a/src/libcore/task.rs b/src/libcore/task.rs index baabd711456b..1f38a10b2e75 100644 --- a/src/libcore/task.rs +++ b/src/libcore/task.rs @@ -338,7 +338,7 @@ type TaskOpts = { // FIXME (#2585): Replace the 'consumed' bit with move mode on self enum TaskBuilder = { opts: TaskOpts, - gen_body: fn@(+fn~()) -> fn~(), + gen_body: fn@(+v: fn~()) -> fn~(), can_not_copy: Option, mut consumed: bool, }; @@ -466,7 +466,7 @@ impl TaskBuilder { * # Failure * Fails if a future_result was already set for this task. */ - fn future_result(blk: fn(+future::Future)) -> TaskBuilder { + fn future_result(blk: fn(+v: future::Future)) -> TaskBuilder { // FIXME (#1087, #1857): Once linked failure and notification are // handled in the library, I can imagine implementing this by just // registering an arbitrary number of task::on_exit handlers and @@ -528,7 +528,7 @@ impl TaskBuilder { * generator by applying the task body which results from the * existing body generator to the new body generator. */ - fn add_wrapper(wrapper: fn@(+fn~()) -> fn~()) -> TaskBuilder { + fn add_wrapper(wrapper: fn@(+v: fn~()) -> fn~()) -> TaskBuilder { let prev_gen_body = self.gen_body; let notify_chan = if self.opts.notify_chan.is_none() { None @@ -578,7 +578,7 @@ impl TaskBuilder { spawn::spawn_raw(move opts, x.gen_body(move f)); } /// Runs a task, while transfering ownership of one argument to the child. - fn spawn_with(+arg: A, +f: fn~(+A)) { + fn spawn_with(+arg: A, +f: fn~(+v: A)) { let arg = ~mut Some(move arg); do self.spawn |move arg, move f|{ f(option::swap_unwrap(arg)) @@ -705,7 +705,7 @@ fn spawn_supervised(+f: fn~()) { task().supervised().spawn(move f) } -fn spawn_with(+arg: A, +f: fn~(+A)) { +fn spawn_with(+arg: A, +f: fn~(+v: A)) { /*! * Runs a task, while transfering ownership of one argument to the * child. @@ -1246,7 +1246,7 @@ fn test_spawn_sched_blocking() { } #[cfg(test)] -fn avoid_copying_the_body(spawnfn: fn(+fn~())) { +fn avoid_copying_the_body(spawnfn: fn(+v: fn~())) { let p = comm::Port::(); let ch = comm::Chan(p); diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs index 3a85055eb023..d91783284c03 100644 --- a/src/libcore/task/local_data.rs +++ b/src/libcore/task/local_data.rs @@ -43,7 +43,7 @@ use local_data_priv::{ * * These two cases aside, the interface is safe. */ -type LocalDataKey = &fn(+@T); +type LocalDataKey = &fn(+v: @T); /** * Remove a task-local data value from the table, returning the diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index 40364acf29a5..21f217d57f46 100644 --- a/src/libcore/task/spawn.rs +++ b/src/libcore/task/spawn.rs @@ -82,7 +82,7 @@ fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) { let was_present = tasks.remove(&task); assert was_present; } -fn taskset_each(tasks: &TaskSet, blk: fn(+*rust_task) -> bool) { +fn taskset_each(tasks: &TaskSet, blk: fn(+v: *rust_task) -> bool) { tasks.each_key(|k| blk(*k)) } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 1e3d0530fb3a..1dea6dbd17c0 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -235,7 +235,8 @@ pure fn with_capacity(capacity: uint) -> ~[T] { * onto the vector being constructed. */ #[inline(always)] -pure fn build_sized(size: uint, builder: fn(push: pure fn(+A))) -> ~[A] { +pure fn build_sized(size: uint, + builder: fn(push: pure fn(+v: A))) -> ~[A] { let mut vec = with_capacity(size); builder(|+x| unsafe { push(vec, move x) }); move vec @@ -252,7 +253,7 @@ pure fn build_sized(size: uint, builder: fn(push: pure fn(+A))) -> ~[A] { * onto the vector being constructed. */ #[inline(always)] -pure fn build(builder: fn(push: pure fn(+A))) -> ~[A] { +pure fn build(builder: fn(push: pure fn(+v: A))) -> ~[A] { build_sized(4, builder) } @@ -270,7 +271,7 @@ pure fn build(builder: fn(push: pure fn(+A))) -> ~[A] { */ #[inline(always)] pure fn build_sized_opt(size: Option, - builder: fn(push: pure fn(+A))) -> ~[A] { + builder: fn(push: pure fn(+v: A))) -> ~[A] { build_sized(size.get_default(4), builder) } @@ -506,7 +507,7 @@ fn unshift(&v: ~[T], +x: T) { } } -fn consume(+v: ~[T], f: fn(uint, +T)) unsafe { +fn consume(+v: ~[T], f: fn(uint, +v: T)) unsafe { do as_imm_buf(v) |p, ln| { for uint::range(0, ln) |i| { let x <- *ptr::offset(p, i); @@ -517,7 +518,7 @@ fn consume(+v: ~[T], f: fn(uint, +T)) unsafe { raw::set_len(v, 0); } -fn consume_mut(+v: ~[mut T], f: fn(uint, +T)) unsafe { +fn consume_mut(+v: ~[mut T], f: fn(uint, +v: T)) unsafe { do as_imm_buf(v) |p, ln| { for uint::range(0, ln) |i| { let x <- *ptr::offset(p, i); @@ -748,7 +749,7 @@ pure fn map(v: &[T], f: fn(v: &T) -> U) -> ~[U] { move result } -fn map_consume(+v: ~[T], f: fn(+T) -> U) -> ~[U] { +fn map_consume(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] { let mut result = ~[]; do consume(move v) |_i, x| { vec::push(result, f(move x)); @@ -1808,7 +1809,7 @@ mod raw { * not bytes). */ #[inline(always)] - unsafe fn form_slice(p: *T, len: uint, f: fn(&& &[T]) -> U) -> U { + unsafe fn form_slice(p: *T, len: uint, f: fn(&&v: &[T]) -> U) -> U { let pair = (p, len * sys::size_of::()); let v : *(&blk/[T]) = ::cast::reinterpret_cast(&ptr::addr_of(pair)); diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs index c5b1aafc0206..4ffe72451138 100644 --- a/src/libstd/arc.rs +++ b/src/libstd/arc.rs @@ -340,7 +340,7 @@ impl &RWARC { * } * ~~~ */ - fn write_downgrade(blk: fn(+RWWriteMode) -> U) -> U { + fn write_downgrade(blk: fn(+v: RWWriteMode) -> U) -> U { let state = unsafe { get_shared_mutable_state(&self.x) }; do borrow_rwlock(state).write_downgrade |write_mode| { check_poison(false, state.failed); diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index 21864ec0e7fb..2c0a3716411d 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -140,7 +140,7 @@ impl BigBitv { } #[inline(always)] - fn each_storage(op: fn(&uint) -> bool) { + fn each_storage(op: fn(&v: uint) -> bool) { for uint::range(0, self.storage.len()) |i| { let mut w = self.storage[i]; let b = !op(w); diff --git a/src/libstd/map.rs b/src/libstd/map.rs index f28d7694b206..adaab0050bbf 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -33,7 +33,7 @@ trait Map { * * Returns true if the key did not already exist in the map */ - fn insert(+K, +V) -> bool; + fn insert(+v: K, +v: V) -> bool; /// Returns true if the map contains a value for the specified key fn contains_key(+key: K) -> bool; diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index 0fd80d4acf48..8fdcc22b4c1a 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -539,7 +539,7 @@ impl &RWlock { * } * ~~~ */ - fn write_downgrade(blk: fn(+RWlockWriteMode) -> U) -> U { + fn write_downgrade(blk: fn(+v: RWlockWriteMode) -> U) -> U { // Implementation slightly different from the slicker 'write's above. // The exit path is conditional on whether the caller downgrades. let mut _release = None; diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 3f41c03b927d..94536924afe3 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -34,7 +34,7 @@ type spanned = {node: T, span: span}; /* can't import macros yet, so this is copied from token.rs. See its comment * there. */ macro_rules! interner_key ( - () => (cast::transmute::<(uint, uint), &fn(+@@token::ident_interner)>( + () => (cast::transmute::<(uint, uint), &fn(+v: @@token::ident_interner)>( (-3 as uint, 0u))) ) diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs index 5e99314712fb..4ebb85010411 100644 --- a/src/libsyntax/ext/auto_serialize.rs +++ b/src/libsyntax/ext/auto_serialize.rs @@ -351,8 +351,8 @@ fn ser_variant(cx: ext_ctxt, span: span, -s: @ast::expr, pfn: fn(~[@ast::pat]) -> ast::pat_, - bodyfn: fn(-@ast::expr, ast::blk) -> @ast::expr, - argfn: fn(-@ast::expr, uint, ast::blk) -> @ast::expr) + bodyfn: fn(-v: @ast::expr, ast::blk) -> @ast::expr, + argfn: fn(-v: @ast::expr, uint, ast::blk) -> @ast::expr) -> ast::arm { let vnames = do vec::from_fn(vec::len(tys)) |i| { cx.parse_sess().interner.intern(@fmt!("__v%u", i)) @@ -535,7 +535,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map, fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident, tps: ~[ast::ty_param], f: fn(ext_ctxt, ser_tps_map, - -@ast::expr, -@ast::expr) -> ~[@ast::stmt]) + -v: @ast::expr, -v: @ast::expr) -> ~[@ast::stmt]) -> @ast::item { let ext_cx = cx; // required for #ast @@ -747,7 +747,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map, fn mk_deser_fn(cx: ext_ctxt, span: span, name: ast::ident, tps: ~[ast::ty_param], - f: fn(ext_ctxt, deser_tps_map, -@ast::expr) -> @ast::expr) + f: fn(ext_ctxt, deser_tps_map, -v: @ast::expr) -> @ast::expr) -> @ast::item { let ext_cx = cx; // required for #ast diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index ffe86c94a243..dbe475c1b509 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -167,7 +167,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, // When we enter a module, record it, for the sake of `module!` fn expand_item(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, &&it: @ast::item, fld: ast_fold, - orig: fn@(&&@ast::item, ast_fold) -> Option<@ast::item>) + orig: fn@(&&v: @ast::item, ast_fold) -> Option<@ast::item>) -> Option<@ast::item> { let is_mod = match it.node { diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 1b25ea73f07d..bfe0f4dd0e64 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -77,9 +77,9 @@ trait ext_ctxt_ast_builder { fn item_ty(name: ident, span: span, ty: @ast::ty) -> @ast::item; fn ty_vars(+ty_params: ~[ast::ty_param]) -> ~[@ast::ty]; fn ty_field_imm(name: ident, ty: @ast::ty) -> ast::ty_field; - fn ty_rec(+~[ast::ty_field]) -> @ast::ty; + fn ty_rec(+v: ~[ast::ty_field]) -> @ast::ty; fn field_imm(name: ident, e: @ast::expr) -> ast::field; - fn rec(+~[ast::field]) -> @ast::expr; + fn rec(+v: ~[ast::field]) -> @ast::expr; fn block(+stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk; fn stmt_let(ident: ident, e: @ast::expr) -> @ast::stmt; fn stmt_expr(e: @ast::expr) -> @ast::stmt; diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index f9b1959f0517..07362e1b31e6 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -20,27 +20,27 @@ export extensions; trait ast_fold { fn fold_crate(crate) -> crate; - fn fold_crate_directive(&&@crate_directive) -> @crate_directive; - fn fold_view_item(&&@view_item) -> @view_item; - fn fold_foreign_item(&&@foreign_item) -> @foreign_item; - fn fold_item(&&@item) -> Option<@item>; - fn fold_struct_field(&&@struct_field) -> @struct_field; + fn fold_crate_directive(&&v: @crate_directive) -> @crate_directive; + fn fold_view_item(&&v: @view_item) -> @view_item; + fn fold_foreign_item(&&v: @foreign_item) -> @foreign_item; + fn fold_item(&&v: @item) -> Option<@item>; + fn fold_struct_field(&&v: @struct_field) -> @struct_field; fn fold_item_underscore(item_) -> item_; - fn fold_method(&&@method) -> @method; + fn fold_method(&&v: @method) -> @method; fn fold_block(blk) -> blk; - fn fold_stmt(&&@stmt) -> @stmt; + fn fold_stmt(&&v: @stmt) -> @stmt; fn fold_arm(arm) -> arm; - fn fold_pat(&&@pat) -> @pat; - fn fold_decl(&&@decl) -> @decl; - fn fold_expr(&&@expr) -> @expr; - fn fold_ty(&&@ty) -> @ty; + fn fold_pat(&&v: @pat) -> @pat; + fn fold_decl(&&v: @decl) -> @decl; + fn fold_expr(&&v: @expr) -> @expr; + fn fold_ty(&&v: @ty) -> @ty; fn fold_mod(_mod) -> _mod; fn fold_foreign_mod(foreign_mod) -> foreign_mod; fn fold_variant(variant) -> variant; - fn fold_ident(&&ident) -> ident; - fn fold_path(&&@path) -> @path; - fn fold_local(&&@local) -> @local; - fn map_exprs(fn@(&&@expr) -> @expr, ~[@expr]) -> ~[@expr]; + fn fold_ident(&&v: ident) -> ident; + fn fold_path(&&v: @path) -> @path; + fn fold_local(&&v: @local) -> @local; + fn map_exprs(fn@(&&v: @expr) -> @expr, ~[@expr]) -> ~[@expr]; fn new_id(node_id) -> node_id; fn new_span(span) -> span; } @@ -53,11 +53,11 @@ type ast_fold_precursor = @{ fold_crate_directive: fn@(crate_directive_, span, ast_fold) -> (crate_directive_, 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_foreign_item: fn@(&&v: @foreign_item, ast_fold) -> @foreign_item, + fold_item: fn@(&&v: @item, ast_fold) -> Option<@item>, + fold_struct_field: fn@(&&v: @struct_field, ast_fold) -> @struct_field, fold_item_underscore: fn@(item_, ast_fold) -> item_, - fold_method: fn@(&&@method, ast_fold) -> @method, + fold_method: fn@(&&v: @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, @@ -68,10 +68,10 @@ type ast_fold_precursor = @{ 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_ident: fn@(&&v: 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], + map_exprs: fn@(fn@(&&v: @expr) -> @expr, ~[@expr]) -> ~[@expr], new_id: fn@(node_id) -> node_id, new_span: fn@(span) -> span}; @@ -643,7 +643,7 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ { /* temporarily eta-expand because of a compiler bug with using `fn` as a value */ -fn noop_map_exprs(f: fn@(&&@expr) -> @expr, es: ~[@expr]) -> ~[@expr] { +fn noop_map_exprs(f: fn@(&&v: @expr) -> @expr, es: ~[@expr]) -> ~[@expr] { return vec::map(es, |x| f(*x)); } @@ -773,7 +773,7 @@ impl ast_fold_precursor: ast_fold { let (n, s) = self.fold_local(x.node, x.span, self as ast_fold); return @{node: n, span: self.new_span(s)}; } - fn map_exprs(f: fn@(&&@expr) -> @expr, e: ~[@expr]) -> ~[@expr] { + fn map_exprs(f: fn@(&&v: @expr) -> @expr, e: ~[@expr]) -> ~[@expr] { self.map_exprs(f, e) } fn new_id(node_id: ast::node_id) -> node_id { diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 3891e7b6d177..d787123bf610 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -21,7 +21,8 @@ pub enum ObsoleteSyntax { ObsoleteWith, ObsoleteClassMethod, ObsoleteClassTraits, - ObsoletePrivSection + ObsoletePrivSection, + ObsoleteModeInFnType } #[cfg(stage0)] @@ -99,6 +100,11 @@ impl parser : ObsoleteReporter { "the `priv` keyword is applied to individual items, methods, \ and fields" ), + ObsoleteModeInFnType => ( + "mode without identifier in fn type", + "to use a (deprecated) mode in a fn type, you should \ + give the argument an explicit name (like `&&v: int`)" + ), }; self.report(sp, kind, kind_str, desc); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index a6ad5b354843..f2e7245a1d47 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -19,7 +19,8 @@ use obsolete::{ ObsoleteReporter, ObsoleteSyntax, ObsoleteLowerCaseKindBounds, ObsoleteLet, ObsoleteFieldTerminator, ObsoleteStructCtor, - ObsoleteWith, ObsoleteClassMethod, ObsoleteClassTraits + ObsoleteWith, ObsoleteClassMethod, ObsoleteClassTraits, + ObsoleteModeInFnType }; use ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute, bind_by_ref, bind_by_implicit_ref, bind_by_value, bind_by_move, @@ -618,6 +619,15 @@ impl parser { } else { special_idents::invalid } }; + match m { + expl(_) => { + if i == special_idents::invalid { + self.obsolete(copy self.span, ObsoleteModeInFnType); + } + } + _ => {} + } + let t = self.parse_ty(false); {mode: m, ty: t, ident: i, id: self.get_id()} @@ -1585,7 +1595,7 @@ impl parser { } fn parse_sugary_call_expr(keyword: ~str, - ctor: fn(+@expr) -> expr_) -> @expr { + ctor: fn(+v: @expr) -> expr_) -> @expr { let lo = self.last_span; // Parse the callee `foo` in // for foo || { @@ -2400,7 +2410,7 @@ impl parser { fn(parser) -> arg_or_capture_item) -> (self_ty, fn_decl, capture_clause) { - fn maybe_parse_self_ty(cnstr: fn(+mutability) -> ast::self_ty_, + fn maybe_parse_self_ty(cnstr: fn(+v: mutability) -> ast::self_ty_, p: parser) -> ast::self_ty_ { // We need to make sure it isn't a mode or a type if p.token_is_keyword(~"self", p.look_ahead(1)) || diff --git a/src/test/bench/pingpong.rs b/src/test/bench/pingpong.rs index 3d1d4985ee0a..570ec8c0b6bf 100644 --- a/src/test/bench/pingpong.rs +++ b/src/test/bench/pingpong.rs @@ -65,7 +65,7 @@ macro_rules! follow ( ) fn switch(+endp: pipes::RecvPacketBuffered, - f: fn(+Option) -> U) -> U { + f: fn(+v: Option) -> U) -> U { f(pipes::try_recv(endp)) } diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs index 6fe850f45d02..8bb315576934 100644 --- a/src/test/bench/task-perf-word-count-generic.rs +++ b/src/test/bench/task-perf-word-count-generic.rs @@ -80,7 +80,7 @@ fn reduce(&&word: ~str, get: map_reduce::getter) { let mut count = 0; loop { match get() { Some(_) => { count += 1; } None => { break; } } } - + io::println(fmt!("%s\t%?", word, count)); } @@ -89,7 +89,7 @@ struct box { } impl box { - fn swap(f: fn(+T) -> T) { + fn swap(f: fn(+v: T) -> T) { let mut tmp = None; self.contents <-> tmp; self.contents = Some(f(option::unwrap(tmp))); diff --git a/src/test/compile-fail/arg-style-mismatch.rs b/src/test/compile-fail/arg-style-mismatch.rs index 9a6396c9147a..58f126f7f4e5 100644 --- a/src/test/compile-fail/arg-style-mismatch.rs +++ b/src/test/compile-fail/arg-style-mismatch.rs @@ -1,5 +1,5 @@ // error-pattern: mismatched types fn f(&&_x: int) {} -fn g(_a: fn(+int)) {} +fn g(_a: fn(+v: int)) {} fn main() { g(f); } diff --git a/src/test/compile-fail/issue-2766-a.rs b/src/test/compile-fail/issue-2766-a.rs index 28042e77a5e4..75e524e27ac4 100644 --- a/src/test/compile-fail/issue-2766-a.rs +++ b/src/test/compile-fail/issue-2766-a.rs @@ -4,7 +4,7 @@ mod stream { mod server { #[legacy_exports]; impl stream { - fn recv() -> extern fn(+stream) -> stream::stream { + fn recv() -> extern fn(+v: stream) -> stream::stream { // resolve really should report just one error here. // Change the test case when it changes. fn recv(+pipe: stream) -> stream::stream { //~ ERROR attempt to use a type argument out of scope diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs index 95abfc6cb016..8c25d94db3be 100644 --- a/src/test/run-pass/class-impl-very-parameterized-trait.rs +++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs @@ -70,7 +70,7 @@ impl cat : Map { } } - pure fn each(f: fn(+int, +T) -> bool) { + pure fn each(f: fn(+v: int, +v: T) -> bool) { let mut n = int::abs(self.meows); while n > 0 { if !f(n, self.name) { break; } @@ -78,10 +78,10 @@ impl cat : Map { } } - pure fn each_key(&&f: fn(+int) -> bool) { + pure fn each_key(&&f: fn(+v: int) -> bool) { for self.each |k, _v| { if !f(k) { break; } loop;}; } - pure fn each_value(&&f: fn(+T) -> bool) { + pure fn each_value(&&f: fn(+v: T) -> bool) { for self.each |_k, v| { if !f(v) { break; } loop;}; } diff --git a/src/test/run-pass/fixed-point-bind-box.rs b/src/test/run-pass/fixed-point-bind-box.rs index a6553a3ab1be..c4220f10e840 100644 --- a/src/test/run-pass/fixed-point-bind-box.rs +++ b/src/test/run-pass/fixed-point-bind-box.rs @@ -9,7 +9,7 @@ fn fix(f: extern fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { return {|a|fix_help(f, a)}; } -fn fact_(f: fn@(&&int) -> int, &&n: int) -> int { +fn fact_(f: fn@(&&v: int) -> int, &&n: int) -> int { // fun fact 0 = 1 return if n == 0 { 1 } else { n * f(n - 1) }; } diff --git a/src/test/run-pass/fixed-point-bind-unique.rs b/src/test/run-pass/fixed-point-bind-unique.rs index a20fb46abcd4..44b642abd7a0 100644 --- a/src/test/run-pass/fixed-point-bind-unique.rs +++ b/src/test/run-pass/fixed-point-bind-unique.rs @@ -9,7 +9,7 @@ fn fix(f: extern fn(fn@(A) -> B, A) -> B) -> fn@(A) -> B { return {|a|fix_help(f, a)}; } -fn fact_(f: fn@(&&int) -> int, &&n: int) -> int { +fn fact_(f: fn@(&&v: int) -> int, &&n: int) -> int { // fun fact 0 = 1 return if n == 0 { 1 } else { n * f(n - 1) }; } diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs index ea1e0ee7e37e..ae6b1a1079ff 100644 --- a/src/test/run-pass/fn-bare-assign.rs +++ b/src/test/run-pass/fn-bare-assign.rs @@ -3,7 +3,7 @@ fn f(i: int, &called: bool) { called = true; } -fn g(f: extern fn(int, &bool), &called: bool) { +fn g(f: extern fn(int, &v: bool), &called: bool) { f(10, called); } diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs index 58c39d7d9e93..cf023fba2bb6 100644 --- a/src/test/run-pass/generic-temporary.rs +++ b/src/test/run-pass/generic-temporary.rs @@ -12,6 +12,6 @@ fn apply(produce: extern fn() -> T, fn main() { let produce: extern fn() -> int = mk; - let consume: extern fn(&&int) = chk; + let consume: extern fn(&&v: int) = chk; apply::(produce, consume); } diff --git a/src/test/run-pass/issue-2185.rs b/src/test/run-pass/issue-2185.rs index e89814763e66..3b3b63308cd4 100644 --- a/src/test/run-pass/issue-2185.rs +++ b/src/test/run-pass/issue-2185.rs @@ -14,7 +14,7 @@ impl fn@(fn(A)): iterable { } impl fn@(fn(uint)): iterable { - fn iter(blk: fn(&&uint)) { self( |i| blk(i) ) } + fn iter(blk: fn(&&v: uint)) { self( |i| blk(i) ) } } fn filter>(self: IA, prd: fn@(A) -> bool, blk: fn(A)) { @@ -41,7 +41,7 @@ fn range(lo: uint, hi: uint, it: fn(uint)) { fn main() { let range: fn@(fn&(uint)) = |a| range(0u, 1000u, a); - let filt: fn@(fn&(&&uint)) = |a| filter( + let filt: fn@(fn&(&&v: uint)) = |a| filter( range, |&&n: uint| n % 3u != 0u && n % 5u != 0u, a); diff --git a/src/test/run-pass/pipe-bank-proto.rs b/src/test/run-pass/pipe-bank-proto.rs index bf8338e5ee59..8ac76293284b 100644 --- a/src/test/run-pass/pipe-bank-proto.rs +++ b/src/test/run-pass/pipe-bank-proto.rs @@ -37,7 +37,7 @@ macro_rules! move_it ( ) fn switch(+endp: pipes::RecvPacket, - f: fn(+Option) -> U) -> U { + f: fn(+v: Option) -> U) -> U { f(pipes::try_recv(endp)) } diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs index 79fe4a1f5749..be00567af677 100644 --- a/src/test/run-pass/sendfn-generic-fn.rs +++ b/src/test/run-pass/sendfn-generic-fn.rs @@ -14,7 +14,7 @@ fn make_generic_record(a: A, b: B) -> pair { return {a: a, b: b}; } -fn test05_start(&&f: fn~(&&float, &&~str) -> pair) { +fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> pair) { let p = f(22.22f, ~"Hi"); log(debug, p); assert p.a == 22.22f; diff --git a/src/test/run-pass/static-method-test.rs b/src/test/run-pass/static-method-test.rs index 2619cc055862..57d6558dd773 100644 --- a/src/test/run-pass/static-method-test.rs +++ b/src/test/run-pass/static-method-test.rs @@ -26,27 +26,27 @@ impl int: bool_like { // A trait for sequences that can be constructed imperatively. trait buildable { static pure fn build_sized(size: uint, - builder: fn(push: pure fn(+A))) -> self; + builder: fn(push: pure fn(+v: A))) -> self; } impl @[A]: buildable { #[inline(always)] static pure fn build_sized(size: uint, - builder: fn(push: pure fn(+A))) -> @[A] { + builder: fn(push: pure fn(+v: A))) -> @[A] { at_vec::build_sized(size, builder) } } impl ~[A]: buildable { #[inline(always)] static pure fn build_sized(size: uint, - builder: fn(push: pure fn(+A))) -> ~[A] { + builder: fn(push: pure fn(+v: A))) -> ~[A] { vec::build_sized(size, builder) } } #[inline(always)] -pure fn build>(builder: fn(push: pure fn(+A))) -> B { +pure fn build>(builder: fn(push: pure fn(+v: A))) -> B { build_sized(4, builder) }