mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Make it illegal to use modes in a fn signature with providing

Browse Source 
an explicit variable name. (Step one to changing the defaults)

First step to #3535
This commit is contained in:
Niko Matsakis 2012-09-23 04:39:27 -07:00
parent 2e7ddee823
commit ba3eebd41d
35 changed files with 111 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/libcore/at_vec.rs
View File

@ -50,7 +50,8 @@ fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
* onto the vector being constructed.
*/
#[inline(always)]
pure fn build_sized<A>(size: uint, builder: fn(push: pure fn(+A))) -> @[A] {
pure fn build_sized<A>(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 @@ fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
* onto the vector being constructed.
*/
#[inline(always)]
pure fn build<A>(builder: fn(push: pure fn(+A))) -> @[A] {
pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> @[A] {
build_sized(4, builder)
}
@ -86,7 +87,7 @@ fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
*/
#[inline(always)]
pure fn build_sized_opt<A>(size: Option<uint>,
builder: fn(push: pure fn(+A))) -> @[A] {
builder: fn(push: pure fn(+v: A))) -> @[A] {
build_sized(size.get_default(4), builder)
}

6
src/libcore/dvec.rs
View File

@ -93,7 +93,7 @@ fn unwrap<A>(+d: DVec<A>) -> ~[A] {
}
#[inline(always)]
fn check_out<B>(f: fn(-~[A]) -> B) -> B {
fn check_out<B>(f: fn(-v: ~[A]) -> B) -> B {
unsafe {
let mut data = cast::reinterpret_cast(&null::<()>());
data <-> self.data;
@ -126,7 +126,7 @@ fn reserve(count: uint) {
* 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 @@ fn swap(f: fn(-~[A]) -> ~[A]) {
* 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)))
}

6
src/libcore/io.rs
View File

@ -827,7 +827,7 @@ fn Res<t>(-arg: Arg<t>) -> Res<t>{
// FIXME (#2004) find better way to create resources within lifetime of
// outer res
fn FILE_res_sync(&&file: FILERes, opt_level: Option<Level>,
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 @@ fn FILE_res_sync(&&file: FILERes, opt_level: Option<Level>,
// fsync fd after executing blk
fn fd_res_sync(&&fd: FdRes, opt_level: Option<Level>,
blk: fn(&&Res<fd_t>)) {
blk: fn(&&v: Res<fd_t>)) {
blk(Res({
val: fd.fd, opt_level: opt_level,
fsync_fn: fn@(&&fd: fd_t, l: Level) -> int {
@ -852,7 +852,7 @@ fn fd_res_sync(&&fd: FdRes, opt_level: Option<Level>,
// Call o.fsync after executing blk
fn obj_sync(&&o: FSyncable, opt_level: Option<Level>,
blk: fn(&&Res<FSyncable>)) {
blk: fn(&&v: Res<FSyncable>)) {
blk(Res({
val: o, opt_level: opt_level,
fsync_fn: fn@(&&o: FSyncable, l: Level) -> int {

6
src/libcore/iter.rs
View File

@ -63,7 +63,7 @@ trait Buildable<A> {
* 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<A,IA:BaseIter<A>>(self: IA, blk: fn(uint, v: &A) -> bool) {
@ -223,7 +223,7 @@ trait Buildable<A> {
* onto the sequence being constructed.
*/
#[inline(always)]
pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+A))) -> B {
pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A))) -> B {
build_sized(4, builder)
}
@ -243,7 +243,7 @@ trait Buildable<A> {
#[inline(always)]
pure fn build_sized_opt<A,B: Buildable<A>>(
size: Option<uint>,
builder: fn(push: pure fn(+A))) -> B {
builder: fn(push: pure fn(+v: A))) -> B {
build_sized(size.get_default(4), builder)
}

6
src/libcore/option.rs
View File

@ -69,7 +69,7 @@ enum Option<T> {
match *opt { Some(ref x) => Some(f(x)), None => None }
}
pure fn map_consume<T, U>(+opt: Option<T>, f: fn(+T) -> U) -> Option<U> {
pure fn map_consume<T, U>(+opt: Option<T>, f: fn(+v: T) -> U) -> Option<U> {
/*!
* As `map`, but consumes the option and gives `f` ownership to avoid
* copying.
@ -107,7 +107,7 @@ enum Option<T> {
}
#[inline(always)]
pure fn while_some<T>(+x: Option<T>, blk: fn(+T) -> Option<T>) {
pure fn while_some<T>(+x: Option<T>, blk: fn(+v: T) -> Option<T>) {
//! Applies a function zero or more times until the result is none.
let mut opt <- x;
@ -248,7 +248,7 @@ impl<T: Copy> Option<T> {
*/
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<T>) { while_some(self, blk) }
pure fn while_some(blk: fn(+v: T) -> Option<T>) { while_some(self, blk) }
}
#[cfg(stage0)]

4
src/libcore/pipes.rs
View File

@ -889,7 +889,7 @@ fn entangle<T: Send>() -> (SendPacket<T>, RecvPacket<T>) {
fn spawn_service<T: Send, Tb: Send>(
init: extern fn() -> (SendPacketBuffered<T, Tb>,
RecvPacketBuffered<T, Tb>),
+service: fn~(+RecvPacketBuffered<T, Tb>))
+service: fn~(+v: RecvPacketBuffered<T, Tb>))
-> SendPacketBuffered<T, Tb>
{
let (client, server) = init();
@ -913,7 +913,7 @@ fn spawn_service<T: Send, Tb: Send>(
fn spawn_service_recv<T: Send, Tb: Send>(
init: extern fn() -> (RecvPacketBuffered<T, Tb>,
SendPacketBuffered<T, Tb>),
+service: fn~(+SendPacketBuffered<T, Tb>))
+service: fn~(+v: SendPacketBuffered<T, Tb>))
-> RecvPacketBuffered<T, Tb>
{
let (client, server) = init();

3
src/libcore/str.rs
View File

@ -2109,7 +2109,8 @@ unsafe fn from_bytes(v: &[const u8]) -> ~str {
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<T>(buf: *u8, len: uint, f: fn(&& &str) -> T) -> T {
unsafe fn buf_as_slice<T>(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))

12
src/libcore/task.rs
View File

@ -338,7 +338,7 @@ impl SchedMode : cmp::Eq {
// 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<util::NonCopyable>,
mut consumed: bool,
};
@ -466,7 +466,7 @@ fn linked() -> TaskBuilder {
* # Failure
* Fails if a future_result was already set for this task.
*/
fn future_result(blk: fn(+future::Future<TaskResult>)) -> TaskBuilder {
fn future_result(blk: fn(+v: future::Future<TaskResult>)) -> 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 @@ fn sched_mode(mode: SchedMode) -> 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 @@ fn spawn(+f: fn~()) {
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<A: Send>(+arg: A, +f: fn~(+A)) {
fn spawn_with<A: Send>(+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<A:Send>(+arg: A, +f: fn~(+A)) {
fn spawn_with<A:Send>(+arg: A, +f: fn~(+v: A)) {
/*!
* Runs a task, while transfering ownership of one argument to the
* child.
@ -1246,7 +1246,7 @@ fn pingpong(po: comm::Port<int>, ch: comm::Chan<int>) {
}
#[cfg(test)]
fn avoid_copying_the_body(spawnfn: fn(+fn~())) {
fn avoid_copying_the_body(spawnfn: fn(+v: fn~())) {
let p = comm::Port::<uint>();
let ch = comm::Chan(p);

2
src/libcore/task/local_data.rs
View File

@ -43,7 +43,7 @@
*
* These two cases aside, the interface is safe.
*/
type LocalDataKey<T: Owned> = &fn(+@T);
type LocalDataKey<T: Owned> = &fn(+v: @T);
/**
* Remove a task-local data value from the table, returning the

2
src/libcore/task/spawn.rs
View File

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

15
src/libcore/vec.rs
View File

@ -235,7 +235,8 @@ fn reserve_at_least<T>(v: &mut ~[T], n: uint) {
* onto the vector being constructed.
*/
#[inline(always)]
pure fn build_sized<A>(size: uint, builder: fn(push: pure fn(+A))) -> ~[A] {
pure fn build_sized<A>(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 @@ fn reserve_at_least<T>(v: &mut ~[T], n: uint) {
* onto the vector being constructed.
*/
#[inline(always)]
pure fn build<A>(builder: fn(push: pure fn(+A))) -> ~[A] {
pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
build_sized(4, builder)
}
@ -270,7 +271,7 @@ fn reserve_at_least<T>(v: &mut ~[T], n: uint) {
*/
#[inline(always)]
pure fn build_sized_opt<A>(size: Option<uint>,
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<T>(&v: ~[T], +x: T) {
}
}
fn consume<T>(+v: ~[T], f: fn(uint, +T)) unsafe {
fn consume<T>(+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<T>(+v: ~[T], f: fn(uint, +T)) unsafe {
raw::set_len(v, 0);
}
fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +T)) unsafe {
fn consume_mut<T>(+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 @@ fn grow_set<T: Copy>(&v: ~[T], index: uint, initval: T, val: T) {
move result
}
fn map_consume<T, U>(+v: ~[T], f: fn(+T) -> U) -> ~[U] {
fn map_consume<T, U>(+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 @@ unsafe fn to_mut_ptr<T>(v: &[mut T]) -> *mut T {
* not bytes).
*/
#[inline(always)]
unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn(&& &[T]) -> U) -> U {
unsafe fn form_slice<T,U>(p: *T, len: uint, f: fn(&&v: &[T]) -> U) -> U {
let pair = (p, len * sys::size_of::<T>());
let v : *(&blk/[T]) =
::cast::reinterpret_cast(&ptr::addr_of(pair));

2
src/libstd/arc.rs
View File

@ -340,7 +340,7 @@ fn read<U>(blk: fn(x: &T) -> U) -> U {
* }
* ~~~
*/
fn write_downgrade<U>(blk: fn(+RWWriteMode<T>) -> U) -> U {
fn write_downgrade<U>(blk: fn(+v: RWWriteMode<T>) -> U) -> U {
let state = unsafe { get_shared_mutable_state(&self.x) };
do borrow_rwlock(state).write_downgrade |write_mode| {
check_poison(false, state.failed);

2
src/libstd/bitv.rs
View File

@ -140,7 +140,7 @@ fn process(b: &BigBitv, nbits: uint, op: fn(uint, uint) -> uint) -> bool {
}
#[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);

2
src/libstd/map.rs
View File

@ -33,7 +33,7 @@ trait Map<K:Eq IterBytes Hash Copy, V: Copy> {
*
* 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;

2
src/libstd/sync.rs
View File

@ -539,7 +539,7 @@ fn write_cond<U>(blk: fn(c: &Condvar) -> U) -> U {
* }
* ~~~
*/
fn write_downgrade<U>(blk: fn(+RWlockWriteMode) -> U) -> U {
fn write_downgrade<U>(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;

2
src/libsyntax/ast.rs
View File

@ -34,7 +34,7 @@ fn deserialize_span<D>(_d: D) -> 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)))
)

8
src/libsyntax/ext/auto_serialize.rs
View File

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

2
src/libsyntax/ext/expand.rs
View File

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

4
src/libsyntax/ext/pipes/ast_builder.rs
View File

@ -77,9 +77,9 @@ fn item_ty_poly(name: ident,
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;

46
src/libsyntax/fold.rs
View File

@ -20,27 +20,27 @@
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 @@ trait ast_fold {
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 @@ trait ast_fold {
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<T>` 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 @@ fn fold_local(&&x: @local) -> @local {
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 {

8
src/libsyntax/parse/obsolete.rs
View File

@ -21,7 +21,8 @@ pub enum ObsoleteSyntax {
ObsoleteWith,
ObsoleteClassMethod,
ObsoleteClassTraits,
ObsoletePrivSection
ObsoletePrivSection,
ObsoleteModeInFnType
}
#[cfg(stage0)]
@ -99,6 +100,11 @@ fn obsolete(sp: span, kind: ObsoleteSyntax) {
"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);

16
src/libsyntax/parse/parser.rs
View File

@ -19,7 +19,8 @@
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 @@ fn parse_arg_general(require_name: bool) -> arg {
} 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 @@ fn parse_else_expr() -> @expr {
}
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 @@ fn parse_fn_decl_with_self(parse_arg_fn:
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)) ||

2
src/test/bench/pingpong.rs
View File

@ -65,7 +65,7 @@ macro_rules! follow (
)
fn switch<T: Send, Tb: Send, U>(+endp: pipes::RecvPacketBuffered<T, Tb>,
f: fn(+Option<T>) -> U) -> U {
f: fn(+v: Option<T>) -> U) -> U {
f(pipes::try_recv(endp))
}

4
src/test/bench/task-perf-word-count-generic.rs
View File

@ -80,7 +80,7 @@ fn reduce(&&word: ~str, get: map_reduce::getter<int>) {
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<T> {
}
impl<T> box<T> {
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)));

2
src/test/compile-fail/arg-style-mismatch.rs
View File

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

2
src/test/compile-fail/issue-2766-a.rs
View File

@ -4,7 +4,7 @@ enum stream<T: Send> { send(T, server::stream<T>), }
mod server {
#[legacy_exports];
impl<T: Send> stream<T> {
fn recv() -> extern fn(+stream<T>) -> stream::stream<T> {
fn recv() -> extern fn(+v: stream<T>) -> stream::stream<T> {
// resolve really should report just one error here.
// Change the test case when it changes.
fn recv(+pipe: stream<T>) -> stream::stream<T> { //~ ERROR attempt to use a type argument out of scope

6
src/test/run-pass/class-impl-very-parameterized-trait.rs
View File

@ -70,7 +70,7 @@ fn remove(+k:int) -> bool {
}
}
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 @@ fn remove(+k:int) -> bool {
}
}
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;};
}

2
src/test/run-pass/fixed-point-bind-box.rs
View File

@ -9,7 +9,7 @@ fn fix<A, B>(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) };
}

2
src/test/run-pass/fixed-point-bind-unique.rs
View File

@ -9,7 +9,7 @@ fn fix<A: Owned, B: Send>(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) };
}

2
src/test/run-pass/fn-bare-assign.rs
View File

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

2
src/test/run-pass/generic-temporary.rs
View File

@ -12,6 +12,6 @@ fn apply<T>(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::<int>(produce, consume);
}

4
src/test/run-pass/issue-2185.rs
View File

@ -14,7 +14,7 @@ impl<A> fn@(fn(A)): iterable<A> {
}
impl fn@(fn(uint)): iterable<uint> {
fn iter(blk: fn(&&uint)) { self( |i| blk(i) ) }
fn iter(blk: fn(&&v: uint)) { self( |i| blk(i) ) }
}
fn filter<A,IA:iterable<A>>(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);

2
src/test/run-pass/pipe-bank-proto.rs
View File

@ -37,7 +37,7 @@ macro_rules! move_it (
)
fn switch<T: Send, U>(+endp: pipes::RecvPacket<T>,
f: fn(+Option<T>) -> U) -> U {
f: fn(+v: Option<T>) -> U) -> U {
f(pipes::try_recv(endp))
}

2
src/test/run-pass/sendfn-generic-fn.rs
View File

@ -14,7 +14,7 @@ fn make_generic_record<A: Copy, B: Copy>(a: A, b: B) -> pair<A,B> {
return {a: a, b: b};
}
fn test05_start(&&f: fn~(&&float, &&~str) -> pair<float, ~str>) {
fn test05_start(&&f: fn~(&&v: float, &&v: ~str) -> pair<float, ~str>) {
let p = f(22.22f, ~"Hi");
log(debug, p);
assert p.a == 22.22f;

8
src/test/run-pass/static-method-test.rs
View File

@ -26,27 +26,27 @@ impl int: bool_like {
// A trait for sequences that can be constructed imperatively.
trait buildable<A> {
static pure fn build_sized(size: uint,
builder: fn(push: pure fn(+A))) -> self;
builder: fn(push: pure fn(+v: A))) -> self;
}
impl<A> @[A]: buildable<A> {
#[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> ~[A]: buildable<A> {
#[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<A, B: buildable<A>>(builder: fn(push: pure fn(+A))) -> B {
pure fn build<A, B: buildable<A>>(builder: fn(push: pure fn(+v: A))) -> B {
build_sized(4, builder)
}