OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Removing explicit uses of + mode

Browse Source 
This removes most explicit uses of the + argument mode. Pending a
snapshot, I had to remove the forbid(deprecated_modes) pragma from
a bunch of files. I'll put it back!

+ mode still has to be used in a few places for functions that get
moved (see task.rs)

The changes outside core and std are due to the to_bytes trait and
making the compiler (with legacy modes on) agree with the libraries
(with legacy modes off) about modes.
This commit is contained in:
Tim Chevalier 2012-10-02 11:37:37 -07:00
parent a5042d58ee
commit f78cdcb636
38 changed files with 282 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/libcore/at_vec.rs
View File

@ -1,7 +1,7 @@
//! Managed vectors
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use cast::transmute;
@ -48,7 +48,7 @@ pub pure fn capacity<T>(v: @[const T]) -> uint {
*/
#[inline(always)]
pub pure fn build_sized<A>(size: uint,
builder: &fn(push: pure fn(+v: A))) -> @[A] {
builder: &fn(push: pure fn(v: A))) -> @[A] {
let mut vec: @[const A] = @[];
unsafe { raw::reserve(&mut vec, size); }
builder(|+x| unsafe { raw::push(&mut vec, move x) });
@ -66,7 +66,7 @@ pub pure fn build_sized<A>(size: uint,
* onto the vector being constructed.
*/
#[inline(always)]
pub pure fn build<A>(builder: &fn(push: pure fn(+v: A))) -> @[A] {
pub pure fn build<A>(builder: &fn(push: pure fn(v: A))) -> @[A] {
build_sized(4, builder)
}
@ -83,8 +83,8 @@ pub pure fn build<A>(builder: &fn(push: pure fn(+v: A))) -> @[A] {
* onto the vector being constructed.
*/
#[inline(always)]
pub pure fn build_sized_opt<A>(+size: Option<uint>,
builder: &fn(push: pure fn(+v: A))) -> @[A] {
pub pure fn build_sized_opt<A>(size: Option<uint>,
builder: &fn(push: pure fn(v: A))) -> @[A] {
build_sized(size.get_default(4), builder)
}
@ -126,7 +126,7 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> @[T] {
* Creates an immutable vector of size `n_elts` and initializes the elements
* to the value `t`.
*/
pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> @[T] {
pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> @[T] {
do build_sized(n_elts) |push| {
let mut i: uint = 0u;
while i < n_elts { push(copy t); i += 1u; }
@ -166,7 +166,7 @@ pub mod raw {
}
#[inline(always)]
pub unsafe fn push<T>(v: &mut @[const T], +initval: T) {
pub unsafe fn push<T>(v: &mut @[const T], initval: T) {
let repr: **VecRepr = ::cast::reinterpret_cast(&v);
let fill = (**repr).unboxed.fill;
if (**repr).unboxed.alloc > fill {
@ -178,7 +178,7 @@ pub mod raw {
}
// This doesn't bother to make sure we have space.
#[inline(always)] // really pretty please
pub unsafe fn push_fast<T>(v: &mut @[const T], +initval: T) {
pub unsafe fn push_fast<T>(v: &mut @[const T], initval: T) {
let repr: **VecRepr = ::cast::reinterpret_cast(&v);
let fill = (**repr).unboxed.fill;
(**repr).unboxed.fill += sys::size_of::<T>();
@ -187,7 +187,7 @@ pub mod raw {
rusti::move_val_init(*p, move initval);
}
pub unsafe fn push_slow<T>(v: &mut @[const T], +initval: T) {
pub unsafe fn push_slow<T>(v: &mut @[const T], initval: T) {
reserve_at_least(v, v.len() + 1u);
push_fast(v, move initval);
}

18
src/libcore/cast.rs
View File

@ -21,7 +21,7 @@ pub unsafe fn reinterpret_cast<T, U>(src: &T) -> U {
* reinterpret_cast on managed pointer types.
*/
#[inline(always)]
pub unsafe fn forget<T>(+thing: T) { rusti::forget(move thing); }
pub unsafe fn forget<T>(thing: T) { rusti::forget(move thing); }
/**
* Force-increment the reference count on a shared box. If used
@ -29,7 +29,7 @@ pub unsafe fn forget<T>(+thing: T) { rusti::forget(move thing); }
* and/or reinterpret_cast when such calls would otherwise scramble a box's
* reference count
*/
pub unsafe fn bump_box_refcount<T>(+t: @T) { forget(move t); }
pub unsafe fn bump_box_refcount<T>(t: @T) { forget(move t); }
/**
* Transform a value of one type into a value of another type.
@ -40,7 +40,7 @@ pub unsafe fn bump_box_refcount<T>(+t: @T) { forget(move t); }
* assert transmute("L") == ~[76u8, 0u8];
*/
#[inline(always)]
pub unsafe fn transmute<L, G>(+thing: L) -> G {
pub unsafe fn transmute<L, G>(thing: L) -> G {
let newthing: G = reinterpret_cast(&thing);
forget(move thing);
move newthing
@ -48,33 +48,33 @@ pub unsafe fn transmute<L, G>(+thing: L) -> G {
/// Coerce an immutable reference to be mutable.
#[inline(always)]
pub unsafe fn transmute_mut<T>(+ptr: &a/T) -> &a/mut T { transmute(move ptr) }
pub unsafe fn transmute_mut<T>(ptr: &a/T) -> &a/mut T { transmute(move ptr) }
/// Coerce a mutable reference to be immutable.
#[inline(always)]
pub unsafe fn transmute_immut<T>(+ptr: &a/mut T) -> &a/T {
pub unsafe fn transmute_immut<T>(ptr: &a/mut T) -> &a/T {
transmute(move ptr)
}
/// Coerce a borrowed pointer to have an arbitrary associated region.
#[inline(always)]
pub unsafe fn transmute_region<T>(+ptr: &a/T) -> &b/T { transmute(move ptr) }
pub unsafe fn transmute_region<T>(ptr: &a/T) -> &b/T { transmute(move ptr) }
/// Coerce an immutable reference to be mutable.
#[inline(always)]
pub unsafe fn transmute_mut_unsafe<T>(+ptr: *const T) -> *mut T {
pub unsafe fn transmute_mut_unsafe<T>(ptr: *const T) -> *mut T {
transmute(ptr)
}
/// Coerce an immutable reference to be mutable.
#[inline(always)]
pub unsafe fn transmute_immut_unsafe<T>(+ptr: *const T) -> *T {
pub unsafe fn transmute_immut_unsafe<T>(ptr: *const T) -> *T {
transmute(ptr)
}
/// Coerce a borrowed mutable pointer to have an arbitrary associated region.
#[inline(always)]
pub unsafe fn transmute_mut_region<T>(+ptr: &a/mut T) -> &b/mut T {
pub unsafe fn transmute_mut_region<T>(ptr: &a/mut T) -> &b/mut T {
transmute(move ptr)
}

10
src/libcore/comm.rs
View File

@ -32,8 +32,8 @@ will once again be the preferred module for intertask communication.
*/
// NB: transitionary, de-mode-ing.
#[warn(deprecated_mode)];
// NB: transitionary, de-mode-ing
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use either::Either;
@ -75,7 +75,7 @@ pub fn Port<T: Send>() -> Port<T> {
impl<T: Send> Port<T> {
fn chan() -> Chan<T> { Chan(self) }
fn send(+v: T) { self.chan().send(move v) }
fn send(v: T) { self.chan().send(move v) }
fn recv() -> T { recv(self) }
fn peek() -> bool { peek(self) }
@ -84,7 +84,7 @@ impl<T: Send> Port<T> {
impl<T: Send> Chan<T> {
fn chan() -> Chan<T> { self }
fn send(+v: T) { send(self, move v) }
fn send(v: T) { send(self, move v) }
fn recv() -> T { recv_chan(self) }
fn peek() -> bool { peek_chan(self) }
@ -174,7 +174,7 @@ pub fn Chan<T: Send>(&&p: Port<T>) -> Chan<T> {
* Sends data over a channel. The sent data is moved into the channel,
* whereupon the caller loses access to it.
*/
pub fn send<T: Send>(ch: Chan<T>, +data: T) {
pub fn send<T: Send>(ch: Chan<T>, data: T) {
let Chan_(p) = ch;
let data_ptr = ptr::addr_of(&data) as *();
let res = rustrt::rust_port_id_send(p, data_ptr);

32
src/libcore/dlist.rs
View File

@ -9,7 +9,7 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
*/
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
type DListLink<T> = Option<DListNode<T>>;
@ -80,7 +80,7 @@ impl<T> DListNode<T> {
}
/// Creates a new dlist node with the given data.
pure fn new_dlist_node<T>(+data: T) -> DListNode<T> {
pure fn new_dlist_node<T>(data: T) -> DListNode<T> {
DListNode(@{data: move data, mut linked: false,
mut prev: None, mut next: None})
}
@ -91,13 +91,13 @@ pure fn DList<T>() -> DList<T> {
}
/// Creates a new dlist with a single element
pub pure fn from_elem<T>(+data: T) -> DList<T> {
pub pure fn from_elem<T>(data: T) -> DList<T> {
let list = DList();
unsafe { list.push(move data); }
list
}
pub fn from_vec<T: Copy>(+vec: &[T]) -> DList<T> {
pub fn from_vec<T: Copy>(vec: &[T]) -> DList<T> {
do vec::foldl(DList(), vec) |list,data| {
list.push(*data); // Iterating left-to-right -- add newly to the tail.
list
@ -115,7 +115,7 @@ fn concat<T>(lists: DList<DList<T>>) -> DList<T> {
}
priv impl<T> DList<T> {
pure fn new_link(+data: T) -> DListLink<T> {
pure fn new_link(data: T) -> DListLink<T> {
Some(DListNode(@{data: move data, mut linked: true,
mut prev: None, mut next: None}))
}
@ -142,7 +142,7 @@ priv impl<T> DList<T> {
// Link two nodes together. If either of them are 'none', also sets
// the head and/or tail pointers appropriately.
#[inline(always)]
fn link(+before: DListLink<T>, +after: DListLink<T>) {
fn link(before: DListLink<T>, after: DListLink<T>) {
match before {
Some(neighbour) => neighbour.next = after,
None => self.hd = after
@ -163,12 +163,12 @@ priv impl<T> DList<T> {
self.size -= 1;
}
fn add_head(+nobe: DListLink<T>) {
fn add_head(nobe: DListLink<T>) {
self.link(nobe, self.hd); // Might set tail too.
self.hd = nobe;
self.size += 1;
}
fn add_tail(+nobe: DListLink<T>) {
fn add_tail(nobe: DListLink<T>) {
self.link(self.tl, nobe); // Might set head too.
self.tl = nobe;
self.size += 1;
@ -198,27 +198,27 @@ impl<T> DList<T> {
pure fn is_not_empty() -> bool { self.len() != 0 }
/// Add data to the head of the list. O(1).
fn push_head(+data: T) {
fn push_head(data: T) {
self.add_head(self.new_link(move data));
}
/**
* Add data to the head of the list, and get the new containing
* node. O(1).
*/
fn push_head_n(+data: T) -> DListNode<T> {
fn push_head_n(data: T) -> DListNode<T> {
let mut nobe = self.new_link(move data);
self.add_head(nobe);
option::get(&nobe)
}
/// Add data to the tail of the list. O(1).
fn push(+data: T) {
fn push(data: T) {
self.add_tail(self.new_link(move data));
}
/**
* Add data to the tail of the list, and get the new containing
* node. O(1).
*/
fn push_n(+data: T) -> DListNode<T> {
fn push_n(data: T) -> DListNode<T> {
let mut nobe = self.new_link(move data);
self.add_tail(nobe);
option::get(&nobe)
@ -227,7 +227,7 @@ impl<T> DList<T> {
* Insert data into the middle of the list, left of the given node.
* O(1).
*/
fn insert_before(+data: T, neighbour: DListNode<T>) {
fn insert_before(data: T, neighbour: DListNode<T>) {
self.insert_left(self.new_link(move data), neighbour);
}
/**
@ -242,7 +242,7 @@ impl<T> DList<T> {
* Insert data in the middle of the list, left of the given node,
* and get its containing node. O(1).
*/
fn insert_before_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> {
fn insert_before_n(data: T, neighbour: DListNode<T>) -> DListNode<T> {
let mut nobe = self.new_link(move data);
self.insert_left(nobe, neighbour);
option::get(&nobe)
@ -251,7 +251,7 @@ impl<T> DList<T> {
* Insert data into the middle of the list, right of the given node.
* O(1).
*/
fn insert_after(+data: T, neighbour: DListNode<T>) {
fn insert_after(data: T, neighbour: DListNode<T>) {
self.insert_right(neighbour, self.new_link(move data));
}
/**
@ -266,7 +266,7 @@ impl<T> DList<T> {
* Insert data in the middle of the list, right of the given node,
* and get its containing node. O(1).
*/
fn insert_after_n(+data: T, neighbour: DListNode<T>) -> DListNode<T> {
fn insert_after_n(data: T, neighbour: DListNode<T>) -> DListNode<T> {
let mut nobe = self.new_link(move data);
self.insert_right(neighbour, nobe);
option::get(&nobe)

28
src/libcore/dvec.rs
View File

@ -10,7 +10,7 @@ Note that recursive use is not permitted.
*/
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use cast::reinterpret_cast;
@ -61,17 +61,17 @@ pub fn DVec<A>() -> DVec<A> {
}
/// Creates a new dvec with a single element
pub fn from_elem<A>(+e: A) -> DVec<A> {
pub fn from_elem<A>(e: A) -> DVec<A> {
DVec_({mut data: ~[move e]})
}
/// Creates a new dvec with the contents of a vector
pub fn from_vec<A>(+v: ~[A]) -> DVec<A> {
pub fn from_vec<A>(v: ~[A]) -> DVec<A> {
DVec_({mut data: move v})
}
/// Consumes the vector and returns its contents
pub fn unwrap<A>(+d: DVec<A>) -> ~[A] {
pub fn unwrap<A>(d: DVec<A>) -> ~[A] {
let DVec_({data: v}) <- d;
move v
}
@ -87,7 +87,7 @@ priv impl<A> DVec<A> {
}
#[inline(always)]
fn check_out<B>(f: &fn(+v: ~[A]) -> B) -> B {
fn check_out<B>(f: &fn(v: ~[A]) -> B) -> B {
unsafe {
let mut data = cast::reinterpret_cast(&null::<()>());
data <-> self.data;
@ -98,7 +98,7 @@ priv impl<A> DVec<A> {
}
#[inline(always)]
fn give_back(+data: ~[A]) {
fn give_back(data: ~[A]) {
unsafe {
self.data = move data;
}
@ -120,7 +120,7 @@ impl<A> DVec<A> {
* and return a new vector to replace it with.
*/
#[inline(always)]
fn swap(f: &fn(+v: ~[A]) -> ~[A]) {
fn swap(f: &fn(v: ~[A]) -> ~[A]) {
self.check_out(|v| self.give_back(f(move v)))
}
@ -130,7 +130,7 @@ impl<A> DVec<A> {
* and return a new vector to replace it with.
*/
#[inline(always)]
fn swap_mut(f: &fn(+v: ~[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)))
}
@ -148,7 +148,7 @@ impl<A> DVec<A> {
}
/// Overwrite the current contents
fn set(+w: ~[A]) {
fn set(w: ~[A]) {
self.check_not_borrowed();
self.data <- w;
}
@ -164,7 +164,7 @@ impl<A> DVec<A> {
}
/// Insert a single item at the front of the list
fn unshift(+t: A) {
fn unshift(t: A) {
unsafe {
let mut data = cast::reinterpret_cast(&null::<()>());
data <-> self.data;
@ -178,7 +178,7 @@ impl<A> DVec<A> {
}
/// Append a single item to the end of the list
fn push(+t: A) {
fn push(t: A) {
self.check_not_borrowed();
self.data.push(move t);
}
@ -295,7 +295,7 @@ impl<A: Copy> DVec<A> {
}
/// Overwrites the contents of the element at `idx` with `a`
fn set_elt(idx: uint, +a: A) {
fn set_elt(idx: uint, a: A) {
self.check_not_borrowed();
self.data[idx] = a;
}
@ -305,7 +305,7 @@ impl<A: Copy> DVec<A> {
* growing the vector if necessary. New elements will be initialized
* with `initval`
*/
fn grow_set_elt(idx: uint, initval: &A, +val: A) {
fn grow_set_elt(idx: uint, initval: &A, val: A) {
do self.swap |v| {
let mut v = move v;
v.grow_set(idx, initval, val);
@ -354,7 +354,7 @@ impl<A: Copy> DVec<A> {
}
impl<A:Copy> DVec<A>: Index<uint,A> {
pure fn index(+idx: uint) -> A {
pure fn index(idx: uint) -> A {
self.get_elt(idx)
}
}

7
src/libcore/either.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
//! A type that represents one of two alternatives
@ -114,7 +114,8 @@ pub pure fn is_right<T, U>(eith: &Either<T, U>) -> bool {
match *eith { Right(_) => true, _ => false }
}
pub pure fn unwrap_left<T,U>(+eith: Either<T,U>) -> T {
// tjc: fix the next two after a snapshot
pub pure fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
//! Retrieves the value in the left branch. Fails if the either is Right.
match move eith {
@ -122,7 +123,7 @@ pub pure fn unwrap_left<T,U>(+eith: Either<T,U>) -> T {
}
}
pub pure fn unwrap_right<T,U>(+eith: Either<T,U>) -> U {
pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
//! Retrieves the value in the right branch. Fails if the either is Left.
match move eith {

10
src/libcore/extfmt.rs
View File

@ -87,7 +87,7 @@ mod ct {
let mut pieces: ~[Piece] = ~[];
let lim = str::len(s);
let mut buf = ~"";
fn flush_buf(+buf: ~str, pieces: &mut ~[Piece]) -> ~str {
fn flush_buf(buf: ~str, pieces: &mut ~[Piece]) -> ~str {
if buf.len() > 0 {
let piece = PieceString(move buf);
pieces.push(move piece);
@ -323,7 +323,7 @@ mod rt {
let mut s = str::from_char(c);
return unsafe { pad(cv, s, PadNozero) };
}
pure fn conv_str(cv: Conv, +s: &str) -> ~str {
pure fn conv_str(cv: Conv, s: &str) -> ~str {
// For strings, precision is the maximum characters
// displayed
let mut unpadded = match cv.precision {
@ -405,7 +405,7 @@ mod rt {
pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
}
fn pad(cv: Conv, +s: ~str, mode: PadMode) -> ~str {
fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
let mut s = move s; // sadtimes
let uwidth : uint = match cv.width {
CountImplied => return s,
@ -518,7 +518,7 @@ mod rt2 {
let mut s = str::from_char(c);
return unsafe { pad(cv, s, PadNozero) };
}
pure fn conv_str(cv: Conv, +s: &str) -> ~str {
pure fn conv_str(cv: Conv, s: &str) -> ~str {
// For strings, precision is the maximum characters
// displayed
let mut unpadded = match cv.precision {
@ -600,7 +600,7 @@ mod rt2 {
pure fn ne(other: &PadMode) -> bool { !self.eq(other) }
}
fn pad(cv: Conv, +s: ~str, mode: PadMode) -> ~str {
fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
let mut s = move s; // sadtimes
let uwidth : uint = match cv.width {
CountImplied => return s,

6
src/libcore/future.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
/*!
@ -55,7 +55,7 @@ impl<A> Future<A> {
}
}
pub fn from_value<A>(+val: A) -> Future<A> {
pub fn from_value<A>(val: A) -> Future<A> {
/*!
* Create a future from a value
*
@ -66,7 +66,7 @@ pub fn from_value<A>(+val: A) -> Future<A> {
Future {state: Forced(~(move val))}
}
pub fn from_port<A:Send>(+port: future_pipe::client::waiting<A>) ->
pub fn from_port<A:Send>(port: future_pipe::client::waiting<A>) ->
Future<A> {
/*!
* Create a future from a port

4
src/libcore/int-template.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use T = inst::T;
@ -231,7 +231,7 @@ fn test_to_str() {
#[test]
fn test_interfaces() {
fn test<U:num::Num cmp::Eq>(+ten: U) {
fn test<U:num::Num cmp::Eq>(ten: U) {
assert (ten.to_int() == 10);
let two: U = from_int(2);

18
src/libcore/io.rs
View File

@ -813,7 +813,7 @@ pub mod fsync {
}
}
pub fn Res<t: Copy>(+arg: Arg<t>) -> Res<t>{
pub fn Res<t: Copy>(arg: Arg<t>) -> Res<t>{
Res {
arg: move arg
}
@ -822,17 +822,17 @@ pub mod fsync {
pub type Arg<t> = {
val: t,
opt_level: Option<Level>,
fsync_fn: fn@(+f: t, Level) -> int
fsync_fn: fn@(f: t, Level) -> int
};
// fsync file after executing blk
// FIXME (#2004) find better way to create resources within lifetime of
// outer res
pub fn FILE_res_sync(file: &FILERes, opt_level: Option<Level>,
blk: fn(+v: Res<*libc::FILE>)) {
blk: fn(v: Res<*libc::FILE>)) {
blk(move Res({
val: file.f, opt_level: opt_level,
fsync_fn: fn@(+file: *libc::FILE, l: Level) -> int {
fsync_fn: fn@(file: *libc::FILE, l: Level) -> int {
return os::fsync_fd(libc::fileno(file), l) as int;
}
}));
@ -840,10 +840,10 @@ pub mod fsync {
// fsync fd after executing blk
pub fn fd_res_sync(fd: &FdRes, opt_level: Option<Level>,
blk: fn(+v: Res<fd_t>)) {
blk: fn(v: Res<fd_t>)) {
blk(move Res({
val: fd.fd, opt_level: opt_level,
fsync_fn: fn@(+fd: fd_t, l: Level) -> int {
fsync_fn: fn@(fd: fd_t, l: Level) -> int {
return os::fsync_fd(fd, l) as int;
}
}));
@ -853,11 +853,11 @@ pub mod fsync {
pub trait FSyncable { fn fsync(l: Level) -> int; }
// Call o.fsync after executing blk
pub fn obj_sync(+o: FSyncable, opt_level: Option<Level>,
blk: fn(+v: Res<FSyncable>)) {
pub fn obj_sync(o: FSyncable, opt_level: Option<Level>,
blk: fn(v: Res<FSyncable>)) {
blk(Res({
val: o, opt_level: opt_level,
fsync_fn: fn@(+o: FSyncable, l: Level) -> int {
fsync_fn: fn@(o: FSyncable, l: Level) -> int {
return o.fsync(l);
}
}));

10
src/libcore/iter-trait.rs
View File

@ -16,7 +16,7 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
pure fn foldl<B>(b0: B, blk: fn(&B, &A) -> B) -> B {
iter::foldl(&self, move b0, blk)
}
pure fn position(f: fn(&A) -> bool) -> Option<uint> {
@ -30,20 +30,20 @@ impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
}
impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A] {
iter::filter_to_vec(&self, pred)
}
pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
pure fn map_to_vec<B>(op: fn(v: A) -> B) -> ~[B] {
iter::map_to_vec(&self, op)
}
pure fn to_vec() -> ~[A] { iter::to_vec(&self) }
pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(+a: A) -> IB)
pure fn flat_map_to_vec<B:Copy,IB:BaseIter<B>>(op: fn(a: A) -> IB)
-> ~[B] {
iter::flat_map_to_vec(&self, op)
}
pure fn find(p: fn(+a: A) -> bool) -> Option<A> { iter::find(&self, p) }
pure fn find(p: fn(a: A) -> bool) -> Option<A> { iter::find(&self, p) }
}
impl<A: Copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {

27
src/libcore/iter.rs
View File

@ -18,7 +18,7 @@ pub trait ExtendedIter<A> {
pure fn eachi(blk: fn(uint, v: &A) -> bool);
pure fn all(blk: fn(&A) -> bool) -> bool;
pure fn any(blk: fn(&A) -> bool) -> bool;
pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B;
pure fn foldl<B>(b0: B, blk: fn(&B, &A) -> B) -> B;
pure fn position(f: fn(&A) -> bool) -> Option<uint>;
}
@ -36,10 +36,10 @@ pub trait TimesIx{
}
pub trait CopyableIter<A:Copy> {
pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A];
pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B];
pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A];
pure fn map_to_vec<B>(op: fn(v: A) -> B) -> ~[B];
pure fn to_vec() -> ~[A];
pure fn find(p: fn(+a: A) -> bool) -> Option<A>;
pure fn find(p: fn(a: A) -> bool) -> Option<A>;
}
pub trait CopyableOrderedIter<A:Copy Ord> {
@ -64,7 +64,7 @@ pub trait Buildable<A> {
* onto the sequence being constructed.
*/
static pure fn build_sized(size: uint,
builder: fn(push: pure fn(+v: A))) -> self;
builder: fn(push: pure fn(v: A))) -> self;
}
pub pure fn eachi<A,IA:BaseIter<A>>(self: &IA,
@ -93,7 +93,7 @@ pub pure fn any<A,IA:BaseIter<A>>(self: &IA,
}
pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
self: &IA, prd: fn(+a: A) -> bool) -> ~[A] {
self: &IA, prd: fn(a: A) -> bool) -> ~[A] {
do vec::build_sized_opt(self.size_hint()) |push| {
for self.each |a| {
if prd(*a) { push(*a); }
@ -102,7 +102,7 @@ pub pure fn filter_to_vec<A:Copy,IA:BaseIter<A>>(
}
pub pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA,
op: fn(+v: A) -> B)
op: fn(v: A) -> B)
-> ~[B] {
do vec::build_sized_opt(self.size_hint()) |push| {
for self.each |a| {
@ -112,8 +112,7 @@ pub pure fn map_to_vec<A:Copy,B,IA:BaseIter<A>>(self: &IA,
}
pub pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
self: &IA, op: fn(+a: A) -> IB) -> ~[B] {
self: &IA, op: fn(a: A) -> IB) -> ~[B] {
do vec::build |push| {
for self.each |a| {
for op(*a).each |b| {
@ -123,7 +122,7 @@ pub pure fn flat_map_to_vec<A:Copy,B:Copy,IA:BaseIter<A>,IB:BaseIter<B>>(
}
}
pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, +b0: B,
pub pure fn foldl<A,B,IA:BaseIter<A>>(self: &IA, b0: B,
blk: fn(&B, &A) -> B)
-> B {
let mut b <- b0;
@ -206,7 +205,7 @@ pub pure fn max<A:Copy Ord,IA:BaseIter<A>>(self: &IA) -> A {
}
pub pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
p: fn(+a: A) -> bool) -> Option<A> {
p: fn(a: A) -> bool) -> Option<A> {
for self.each |i| {
if p(*i) { return Some(*i) }
}
@ -226,7 +225,7 @@ pub pure fn find<A: Copy,IA:BaseIter<A>>(self: &IA,
* onto the sequence being constructed.
*/
#[inline(always)]
pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A)))
pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(v: A)))
-> B {
build_sized(4, builder)
}
@ -247,7 +246,7 @@ pub pure fn build<A,B: Buildable<A>>(builder: fn(push: pure fn(+v: A)))
#[inline(always)]
pub pure fn build_sized_opt<A,B: Buildable<A>>(
size: Option<uint>,
builder: fn(push: pure fn(+v: A))) -> B {
builder: fn(push: pure fn(v: A))) -> B {
build_sized(size.get_default(4), builder)
}
@ -285,7 +284,7 @@ pub pure fn from_fn<T,BT: Buildable<T>>(n_elts: uint,
* to the value `t`.
*/
pub pure fn from_elem<T: Copy,BT: Buildable<T>>(n_elts: uint,
+t: T) -> BT {
t: T) -> BT {
do build_sized(n_elts) |push| {
let mut i: uint = 0;
while i < n_elts { push(t); i += 1; }

7
src/libcore/mutable.rs
View File

@ -8,8 +8,7 @@ dynamic checks: your program will fail if you attempt to perform
mutation when the data structure should be immutable.
*/
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use util::with;
@ -24,11 +23,11 @@ struct Data<T> {
pub type Mut<T> = Data<T>;
pub fn Mut<T>(+t: T) -> Mut<T> {
pub fn Mut<T>(t: T) -> Mut<T> {
Data {value: t, mode: ReadOnly}
}
pub fn unwrap<T>(+m: Mut<T>) -> T {
pub fn unwrap<T>(m: Mut<T>) -> T {
// Borrowck should prevent us from calling unwrap while the value
// is in use, as that would be a move from a borrowed value.
assert (m.mode as uint) == (ReadOnly as uint);

2
src/libcore/ops.rs
View File

@ -77,6 +77,6 @@ pub trait Shr<RHS,Result> {
#[lang="index"]
pub trait Index<Index,Result> {
pure fn index(+index: Index) -> Result;
pure fn index(index: Index) -> Result;
}

32
src/libcore/option.rs
View File

@ -49,7 +49,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
}
}
pub pure fn expect<T: Copy>(opt: &Option<T>, +reason: ~str) -> T {
pub pure fn expect<T: Copy>(opt: &Option<T>, reason: ~str) -> T {
/*!
* Gets the value out of an option, printing a specified message on
* failure
@ -67,8 +67,8 @@ pub pure fn map<T, U>(opt: &Option<T>, f: fn(x: &T) -> U) -> Option<U> {
match *opt { Some(ref x) => Some(f(x)), None => None }
}
pub pure fn map_consume<T, U>(+opt: Option<T>,
f: fn(+v: T) -> U) -> Option<U> {
pub 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.
@ -76,8 +76,8 @@ pub pure fn map_consume<T, U>(+opt: Option<T>,
if opt.is_some() { Some(f(option::unwrap(move opt))) } else { None }
}
pub pure fn chain<T, U>(+opt: Option<T>,
f: fn(+t: T) -> Option<U>) -> Option<U> {
pub pure fn chain<T, U>(opt: Option<T>,
f: fn(t: T) -> Option<U>) -> Option<U> {
/*!
* Update an optional value by optionally running its content through a
* function that returns an option.
@ -101,7 +101,7 @@ pub pure fn chain_ref<T, U>(opt: &Option<T>,
match *opt { Some(ref x) => f(x), None => None }
}
pub pure fn or<T>(+opta: Option<T>, +optb: Option<T>) -> Option<T> {
pub pure fn or<T>(opta: Option<T>, optb: Option<T>) -> Option<T> {
/*!
* Returns the leftmost some() value, or none if both are none.
*/
@ -112,7 +112,7 @@ pub pure fn or<T>(+opta: Option<T>, +optb: Option<T>) -> Option<T> {
}
#[inline(always)]
pub pure fn while_some<T>(+x: Option<T>, blk: fn(+v: T) -> Option<T>) {
pub 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;
@ -133,13 +133,13 @@ pub pure fn is_some<T>(opt: &Option<T>) -> bool {
!is_none(opt)
}
pub pure fn get_default<T: Copy>(opt: &Option<T>, +def: T) -> T {
pub pure fn get_default<T: Copy>(opt: &Option<T>, def: T) -> T {
//! Returns the contained value or a default
match *opt { Some(copy x) => x, None => def }
}
pub pure fn map_default<T, U>(opt: &Option<T>, +def: U,
pub pure fn map_default<T, U>(opt: &Option<T>, def: U,
f: fn(x: &T) -> U) -> U {
//! Applies a function to the contained value or returns a default
@ -151,10 +151,8 @@ pub pure fn iter<T>(opt: &Option<T>, f: fn(x: &T)) {
match *opt { None => (), Some(ref t) => f(t) }
}
// tjc: shouldn't this be - instead of +?
// then could get rid of some superfluous moves
#[inline(always)]
pub pure fn unwrap<T>(+opt: Option<T>) -> T {
pub pure fn unwrap<T>(opt: Option<T>) -> T {
/*!
* Moves a value out of an option type and returns it.
*
@ -174,7 +172,7 @@ pub fn swap_unwrap<T>(opt: &mut Option<T>) -> T {
unwrap(util::replace(opt, None))
}
pub pure fn unwrap_expect<T>(+opt: Option<T>, reason: &str) -> T {
pub pure fn unwrap_expect<T>(opt: Option<T>, reason: &str) -> T {
//! As unwrap, but with a specified failure message.
if opt.is_none() { fail reason.to_unique(); }
unwrap(move opt)
@ -197,7 +195,7 @@ impl<T> &Option<T> {
chain_ref(self, f)
}
/// Applies a function to the contained value or returns a default
pure fn map_default<U>(+def: U, f: fn(x: &T) -> U) -> U
pure fn map_default<U>(def: U, f: fn(x: &T) -> U) -> U
{ map_default(self, move def, f) }
/// Performs an operation on the contained value by reference
pure fn iter(f: fn(x: &T)) { iter(self, f) }
@ -216,7 +214,7 @@ impl<T: Copy> Option<T> {
* Fails if the value equals `none`
*/
pure fn get() -> T { get(&self) }
pure fn get_default(+def: T) -> T { get_default(&self, def) }
pure fn get_default(def: T) -> T { get_default(&self, def) }
/**
* Gets the value out of an option, printing a specified message on
* failure
@ -225,9 +223,9 @@ impl<T: Copy> Option<T> {
*
* Fails if the value equals `none`
*/
pure fn expect(+reason: ~str) -> T { expect(&self, reason) }
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(+v: T) -> Option<T>) { while_some(self, blk) }
pure fn while_some(blk: fn(v: T) -> Option<T>) { while_some(self, blk) }
}
impl<T: Eq> Option<T> : Eq {

6
src/libcore/os.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid
#[forbid(deprecated_pattern)];
/*!
@ -768,7 +768,7 @@ struct OverriddenArgs {
val: ~[~str]
}
fn overridden_arg_key(+_v: @OverriddenArgs) {}
fn overridden_arg_key(_v: @OverriddenArgs) {}
pub fn args() -> ~[~str] {
unsafe {
@ -779,7 +779,7 @@ pub fn args() -> ~[~str] {
}
}
pub fn set_args(+new_args: ~[~str]) {
pub fn set_args(new_args: ~[~str]) {
unsafe {
let overridden_args = @OverriddenArgs { val: copy new_args };
task::local_data::local_data_set(overridden_arg_key, overridden_args);

68
src/libcore/pipes.rs
View File

@ -73,7 +73,7 @@ bounded and unbounded protocols allows for less code duplication.
*/
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use cmp::Eq;
@ -169,7 +169,7 @@ impl PacketHeader {
reinterpret_cast(&self.buffer)
}
fn set_buffer<T: Send>(+b: ~Buffer<T>) unsafe {
fn set_buffer<T: Send>(b: ~Buffer<T>) unsafe {
self.buffer = reinterpret_cast(&b);
}
}
@ -227,7 +227,7 @@ pub fn packet<T: Send>() -> *Packet<T> {
#[doc(hidden)]
pub fn entangle_buffer<T: Send, Tstart: Send>(
+buffer: ~Buffer<T>,
buffer: ~Buffer<T>,
init: fn(*libc::c_void, x: &T) -> *Packet<Tstart>)
-> (SendPacketBuffered<Tstart, T>, RecvPacketBuffered<Tstart, T>)
{
@ -239,12 +239,12 @@ pub fn entangle_buffer<T: Send, Tstart: Send>(
#[abi = "rust-intrinsic"]
#[doc(hidden)]
extern mod rusti {
fn atomic_xchg(dst: &mut int, +src: int) -> int;
fn atomic_xchg_acq(dst: &mut int, +src: int) -> int;
fn atomic_xchg_rel(dst: &mut int, +src: int) -> int;
fn atomic_xchg(dst: &mut int, src: int) -> int;
fn atomic_xchg_acq(dst: &mut int, src: int) -> int;
fn atomic_xchg_rel(dst: &mut int, src: int) -> int;
fn atomic_xadd_acq(dst: &mut int, +src: int) -> int;
fn atomic_xsub_rel(dst: &mut int, +src: int) -> int;
fn atomic_xadd_acq(dst: &mut int, src: int) -> int;
fn atomic_xsub_rel(dst: &mut int, src: int) -> int;
}
// If I call the rusti versions directly from a polymorphic function,
@ -265,7 +265,7 @@ pub fn atomic_sub_rel(dst: &mut int, src: int) -> int {
}
#[doc(hidden)]
pub fn swap_task(+dst: &mut *rust_task, src: *rust_task) -> *rust_task {
pub fn swap_task(dst: &mut *rust_task, src: *rust_task) -> *rust_task {
// It might be worth making both acquire and release versions of
// this.
unsafe {
@ -304,14 +304,14 @@ fn wait_event(this: *rust_task) -> *libc::c_void {
}
#[doc(hidden)]
fn swap_state_acq(+dst: &mut State, src: State) -> State {
fn swap_state_acq(dst: &mut State, src: State) -> State {
unsafe {
transmute(rusti::atomic_xchg_acq(transmute(move dst), src as int))
}
}
#[doc(hidden)]
fn swap_state_rel(+dst: &mut State, src: State) -> State {
fn swap_state_rel(dst: &mut State, src: State) -> State {
unsafe {
transmute(rusti::atomic_xchg_rel(transmute(move dst), src as int))
}
@ -343,7 +343,7 @@ struct BufferResource<T: Send> {
}
}
fn BufferResource<T: Send>(+b: ~Buffer<T>) -> BufferResource<T> {
fn BufferResource<T: Send>(b: ~Buffer<T>) -> BufferResource<T> {
//let p = ptr::addr_of(*b);
//error!("take %?", p);
atomic_add_acq(&mut b.header.ref_count, 1);
@ -354,8 +354,8 @@ fn BufferResource<T: Send>(+b: ~Buffer<T>) -> BufferResource<T> {
}
#[doc(hidden)]
pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
+payload: T) -> bool {
pub fn send<T: Send, Tbuffer: Send>(p: SendPacketBuffered<T, Tbuffer>,
payload: T) -> bool {
let header = p.header();
let p_ = p.unwrap();
let p = unsafe { &*p_ };
@ -398,7 +398,7 @@ pub fn send<T: Send, Tbuffer: Send>(+p: SendPacketBuffered<T, Tbuffer>,
Fails if the sender closes the connection.
*/
pub fn recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>) -> T {
pub fn recv<T: Send, Tbuffer: Send>(p: RecvPacketBuffered<T, Tbuffer>) -> T {
option::unwrap_expect(try_recv(move p), "connection closed")
}
@ -408,7 +408,7 @@ Returns `none` if the sender has closed the connection without sending
a message, or `Some(T)` if a message was received.
*/
pub fn try_recv<T: Send, Tbuffer: Send>(+p: RecvPacketBuffered<T, Tbuffer>)
pub fn try_recv<T: Send, Tbuffer: Send>(p: RecvPacketBuffered<T, Tbuffer>)
-> Option<T>
{
let p_ = p.unwrap();
@ -655,8 +655,8 @@ this case, `select2` may return either `left` or `right`.
*/
pub fn select2<A: Send, Ab: Send, B: Send, Bb: Send>(
+a: RecvPacketBuffered<A, Ab>,
+b: RecvPacketBuffered<B, Bb>)
a: RecvPacketBuffered<A, Ab>,
b: RecvPacketBuffered<B, Bb>)
-> Either<(Option<A>, RecvPacketBuffered<B, Bb>),
(RecvPacketBuffered<A, Ab>, Option<B>)>
{
@ -697,7 +697,7 @@ pub fn select2i<A: Selectable, B: Selectable>(a: &A, b: &B) ->
list of the remaining endpoints.
*/
pub fn select<T: Send, Tb: Send>(+endpoints: ~[RecvPacketBuffered<T, Tb>])
pub fn select<T: Send, Tb: Send>(endpoints: ~[RecvPacketBuffered<T, Tb>])
-> (uint, Option<T>, ~[RecvPacketBuffered<T, Tb>])
{
let ready = wait_many(endpoints.map(|p| p.header()));
@ -859,7 +859,7 @@ endpoint is passed to the new task.
pub fn spawn_service<T: Send, Tb: Send>(
init: extern fn() -> (SendPacketBuffered<T, Tb>,
RecvPacketBuffered<T, Tb>),
+service: fn~(+v: RecvPacketBuffered<T, Tb>))
+service: fn~(v: RecvPacketBuffered<T, Tb>))
-> SendPacketBuffered<T, Tb>
{
let (client, server) = init();
@ -883,7 +883,7 @@ receive state.
pub fn spawn_service_recv<T: Send, Tb: Send>(
init: extern fn() -> (RecvPacketBuffered<T, Tb>,
SendPacketBuffered<T, Tb>),
+service: fn~(+v: SendPacketBuffered<T, Tb>))
+service: fn~(v: SendPacketBuffered<T, Tb>))
-> RecvPacketBuffered<T, Tb>
{
let (client, server) = init();
@ -914,10 +914,10 @@ pub trait Channel<T: Send> {
// built in send kind.
/// Sends a message.
fn send(+x: T);
fn send(x: T);
/// Sends a message, or report if the receiver has closed the connection.
fn try_send(+x: T) -> bool;
fn try_send(x: T) -> bool;
}
/// A trait for things that can receive multiple messages.
@ -966,14 +966,14 @@ pub fn stream<T:Send>() -> (Chan<T>, Port<T>) {
}
impl<T: Send> Chan<T>: Channel<T> {
fn send(+x: T) {
fn send(x: T) {
let mut endp = None;
endp <-> self.endp;
self.endp = Some(
streamp::client::data(unwrap(move endp), move x))
}
fn try_send(+x: T) -> bool {
fn try_send(x: T) -> bool {
let mut endp = None;
endp <-> self.endp;
match move streamp::client::try_data(unwrap(move endp), move x) {
@ -1041,7 +1041,7 @@ pub fn PortSet<T: Send>() -> PortSet<T>{
impl<T: Send> PortSet<T> : Recv<T> {
fn add(+port: pipes::Port<T>) {
fn add(port: pipes::Port<T>) {
self.ports.push(move port)
}
@ -1091,7 +1091,7 @@ impl<T: Send> PortSet<T> : Recv<T> {
pub type SharedChan<T: Send> = private::Exclusive<Chan<T>>;
impl<T: Send> SharedChan<T>: Channel<T> {
fn send(+x: T) {
fn send(x: T) {
let mut xx = Some(move x);
do self.with_imm |chan| {
let mut x = None;
@ -1100,7 +1100,7 @@ impl<T: Send> SharedChan<T>: Channel<T> {
}
}
fn try_send(+x: T) -> bool {
fn try_send(x: T) -> bool {
let mut xx = Some(move x);
do self.with_imm |chan| {
let mut x = None;
@ -1111,7 +1111,7 @@ impl<T: Send> SharedChan<T>: Channel<T> {
}
/// Converts a `chan` into a `shared_chan`.
pub fn SharedChan<T:Send>(+c: Chan<T>) -> SharedChan<T> {
pub fn SharedChan<T:Send>(c: Chan<T>) -> SharedChan<T> {
private::exclusive(move c)
}
@ -1165,13 +1165,13 @@ pub fn oneshot<T: Send>() -> (ChanOne<T>, PortOne<T>) {
* Receive a message from a oneshot pipe, failing if the connection was
* closed.
*/
pub fn recv_one<T: Send>(+port: PortOne<T>) -> T {
pub fn recv_one<T: Send>(port: PortOne<T>) -> T {
let oneshot::send(message) = recv(move port);
move message
}
/// Receive a message from a oneshot pipe unless the connection was closed.
pub fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
pub fn try_recv_one<T: Send> (port: PortOne<T>) -> Option<T> {
let message = try_recv(move port);
if message.is_none() { None }
@ -1182,7 +1182,7 @@ pub fn try_recv_one<T: Send> (+port: PortOne<T>) -> Option<T> {
}
/// Send a message on a oneshot pipe, failing if the connection was closed.
pub fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
pub fn send_one<T: Send>(chan: ChanOne<T>, data: T) {
oneshot::client::send(move chan, move data);
}
@ -1190,7 +1190,7 @@ pub fn send_one<T: Send>(+chan: ChanOne<T>, +data: T) {
* Send a message on a oneshot pipe, or return false if the connection was
* closed.
*/
pub fn try_send_one<T: Send>(+chan: ChanOne<T>, +data: T)
pub fn try_send_one<T: Send>(chan: ChanOne<T>, data: T)
-> bool {
oneshot::client::try_send(move chan, move data).is_some()
}
@ -1198,7 +1198,7 @@ pub fn try_send_one<T: Send>(+chan: ChanOne<T>, +data: T)
pub mod rt {
// These are used to hide the option constructors from the
// compiler because their names are changing
pub fn make_some<T>(+val: T) -> Option<T> { Some(move val) }
pub fn make_some<T>(val: T) -> Option<T> { Some(move val) }
pub fn make_none<T>() -> Option<T> { None }
}

10
src/libcore/private.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
#[doc(hidden)];
@ -340,7 +340,7 @@ fn ArcDestruct<T>(data: *libc::c_void) -> ArcDestruct<T> {
}
}
pub unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
pub unsafe fn unwrap_shared_mutable_state<T: Send>(rc: SharedMutableState<T>)
-> T {
struct DeathThroes<T> {
mut ptr: Option<~ArcData<T>>,
@ -413,7 +413,7 @@ pub unsafe fn unwrap_shared_mutable_state<T: Send>(+rc: SharedMutableState<T>)
*/
pub type SharedMutableState<T: Send> = ArcDestruct<T>;
pub unsafe fn shared_mutable_state<T: Send>(+data: T) ->
pub unsafe fn shared_mutable_state<T: Send>(data: T) ->
SharedMutableState<T> {
let data = ~ArcData { count: 1, unwrapper: 0, data: Some(move data) };
unsafe {
@ -502,7 +502,7 @@ struct ExData<T: Send> { lock: LittleLock, mut failed: bool, mut data: T, }
*/
pub struct Exclusive<T: Send> { x: SharedMutableState<ExData<T>> }
pub fn exclusive<T:Send >(+user_data: T) -> Exclusive<T> {
pub fn exclusive<T:Send >(user_data: T) -> Exclusive<T> {
let data = ExData {
lock: LittleLock(), mut failed: false, mut data: user_data
};
@ -544,7 +544,7 @@ impl<T: Send> Exclusive<T> {
}
// FIXME(#2585) make this a by-move method on the exclusive
pub fn unwrap_exclusive<T: Send>(+arc: Exclusive<T>) -> T {
pub fn unwrap_exclusive<T: Send>(arc: Exclusive<T>) -> T {
let Exclusive { x: x } <- arc;
let inner = unsafe { unwrap_shared_mutable_state(move x) };
let ExData { data: data, _ } <- inner;

2
src/libcore/reflect.rs
View File

@ -27,7 +27,7 @@ fn align(size: uint, align: uint) -> uint {
struct MovePtrAdaptor<V: TyVisitor MovePtr> {
inner: V
}
pub fn MovePtrAdaptor<V: TyVisitor MovePtr>(+v: V) -> MovePtrAdaptor<V> {
pub fn MovePtrAdaptor<V: TyVisitor MovePtr>(v: V) -> MovePtrAdaptor<V> {
MovePtrAdaptor { inner: move v }
}

18
src/libcore/result.rs
View File

@ -1,7 +1,7 @@
//! A type representing either success or failure
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use cmp::Eq;
@ -102,7 +102,7 @@ pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
* ok(parse_bytes(buf))
* }
*/
pub fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
pub fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(t: T)
-> Result<U, V>) -> Result<U, V> {
// XXX: Should be writable with move + match
if res.is_ok() {
@ -121,8 +121,8 @@ pub fn chain<T, U: Copy, V: Copy>(+res: Result<T, V>, op: fn(+t: T)
* successful result while handling an error.
*/
pub fn chain_err<T: Copy, U: Copy, V: Copy>(
+res: Result<T, V>,
op: fn(+t: V) -> Result<T, U>)
res: Result<T, V>,
op: fn(t: V) -> Result<T, U>)
-> Result<T, U> {
match move res {
Ok(move t) => Ok(t),
@ -247,12 +247,12 @@ impl<T, E: Copy> Result<T, E> {
}
impl<T: Copy, E: Copy> Result<T, E> {
fn chain<U:Copy>(op: fn(+t: T) -> Result<U,E>) -> Result<U,E> {
fn chain<U:Copy>(op: fn(t: T) -> Result<U,E>) -> Result<U,E> {
// XXX: Bad copy
chain(copy self, op)
}
fn chain_err<F:Copy>(op: fn(+t: E) -> Result<T,F>) -> Result<T,F> {
fn chain_err<F:Copy>(op: fn(t: E) -> Result<T,F>) -> Result<T,F> {
// XXX: Bad copy
chain_err(copy self, op)
}
@ -348,7 +348,7 @@ pub fn iter_vec2<S,T,U:Copy>(ss: &[S], ts: &[T],
}
/// Unwraps a result, assuming it is an `ok(T)`
pub fn unwrap<T, U>(+res: Result<T, U>) -> T {
pub fn unwrap<T, U>(res: Result<T, U>) -> T {
match move res {
Ok(move t) => move t,
Err(_) => fail ~"unwrap called on an err result"
@ -356,7 +356,7 @@ pub fn unwrap<T, U>(+res: Result<T, U>) -> T {
}
/// Unwraps a result, assuming it is an `err(U)`
pub fn unwrap_err<T, U>(+res: Result<T, U>) -> U {
pub fn unwrap_err<T, U>(res: Result<T, U>) -> U {
match move res {
Err(move u) => move u,
Ok(_) => fail ~"unwrap called on an ok result"
@ -389,7 +389,7 @@ mod tests {
#[legacy_exports];
fn op1() -> result::Result<int, ~str> { result::Ok(666) }
fn op2(+i: int) -> result::Result<uint, ~str> {
fn op2(i: int) -> result::Result<uint, ~str> {
result::Ok(i as uint + 1u)
}

6
src/libcore/run.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
//! Process spawning
@ -224,7 +224,7 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
drop { destroy_repr(&self.r); }
}
fn ProgRes(+r: ProgRepr) -> ProgRes {
fn ProgRes(r: ProgRepr) -> ProgRes {
ProgRes {
r: r
}
@ -328,7 +328,7 @@ pub fn program_output(prog: &str, args: &[~str]) ->
return {status: status, out: move outs, err: move errs};
}
fn writeclose(fd: c_int, +s: ~str) {
fn writeclose(fd: c_int, s: ~str) {
use io::WriterUtil;
error!("writeclose %d, %s", fd as int, s);

8
src/libcore/send_map.rs
View File

@ -15,7 +15,7 @@ use to_bytes::IterBytes;
pub trait SendMap<K:Eq Hash, V: Copy> {
// FIXME(#3148) ^^^^ once find_ref() works, we can drop V:copy
fn insert(&mut self, +k: K, +v: V) -> bool;
fn insert(&mut self, k: K, +v: V) -> bool;
fn remove(&mut self, k: &K) -> bool;
fn clear(&mut self);
pure fn len(&const self) -> uint;
@ -161,7 +161,7 @@ pub mod linear {
}
}
fn insert_opt_bucket(&mut self, +bucket: Option<Bucket<K,V>>) {
fn insert_opt_bucket(&mut self, bucket: Option<Bucket<K,V>>) {
match move bucket {
Some(Bucket {hash: move hash,
key: move key,
@ -175,7 +175,7 @@ pub mod linear {
/// Inserts the key value pair into the buckets.
/// Assumes that there will be a bucket.
/// True if there was no previous entry with that key
fn insert_internal(&mut self, hash: uint, +k: K, +v: V) -> bool {
fn insert_internal(&mut self, hash: uint, k: K, v: V) -> bool {
match self.bucket_for_key_with_hash(self.buckets, hash, &k) {
TableFull => { fail ~"Internal logic error"; }
FoundHole(idx) => {
@ -206,7 +206,7 @@ pub mod linear {
}
impl<K:Hash IterBytes Eq,V> LinearMap<K,V> {
fn insert(&mut self, +k: K, +v: V) -> bool {
fn insert(&mut self, k: K, v: V) -> bool {
if self.size >= self.resize_at {
// n.b.: We could also do this after searching, so
// that we do not resize if this call to insert is

2
src/libcore/stackwalk.rs
View File

@ -1,5 +1,7 @@
#[doc(hidden)]; // FIXME #3538
#[legacy_modes]; // tjc: remove after snapshot
// NB: transitionary, de-mode-ing.
// XXX: Can't do this because frame_address needs a deprecated mode.
//#[forbid(deprecated_mode)];

2
src/libcore/str.rs
View File

@ -175,7 +175,7 @@ pub fn push_str(lhs: &const ~str, rhs: &str) {
/// Concatenate two strings together
#[inline(always)]
pub pure fn append(+lhs: ~str, rhs: &str) -> ~str {
pub pure fn append(lhs: ~str, rhs: &str) -> ~str {
let mut v <- lhs;
unsafe {
push_str_no_overallocate(&mut v, rhs);

2
src/libcore/sys.rs
View File

@ -83,7 +83,7 @@ pub pure fn pref_align_of<T>() -> uint {
/// Returns the refcount of a shared box (as just before calling this)
#[inline(always)]
pub pure fn refcount<T>(+t: @T) -> uint {
pub pure fn refcount<T>(t: @T) -> uint {
unsafe {
let ref_ptr: *uint = cast::reinterpret_cast(&t);
*ref_ptr - 1

16
src/libcore/task.rs
View File

@ -1,5 +1,5 @@
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
/*!
@ -232,7 +232,7 @@ pub enum TaskBuilder = {
pub fn task() -> TaskBuilder {
TaskBuilder({
opts: default_task_opts(),
gen_body: |body| move body, // Identity function
gen_body: |+body| move body, // Identity function
can_not_copy: None,
mut consumed: false,
})
@ -347,7 +347,7 @@ impl TaskBuilder {
* # Failure
* Fails if a future_result was already set for this task.
*/
fn future_result(blk: fn(+v: 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
@ -459,9 +459,9 @@ 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<A: Send>(+arg: A, +f: fn~(+v: 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|{
do self.spawn |move arg, move f| {
f(option::swap_unwrap(arg))
}
}
@ -473,7 +473,7 @@ impl TaskBuilder {
* child task, passes the port to child's body, and returns a channel
* linked to the port to the parent.
*
* This encapsulates Some boilerplate handshaking logic that would
* This encapsulates some boilerplate handshaking logic that would
* otherwise be required to establish communication from the parent
* to the child.
*/
@ -1149,7 +1149,7 @@ fn test_avoid_copying_the_body_spawn() {
#[test]
fn test_avoid_copying_the_body_spawn_listener() {
do avoid_copying_the_body |f| {
do avoid_copying_the_body |+f| {
spawn_listener(fn~(move f, _po: comm::Port<int>) {
f();
});
@ -1167,7 +1167,7 @@ fn test_avoid_copying_the_body_task_spawn() {
#[test]
fn test_avoid_copying_the_body_spawn_listener_1() {
do avoid_copying_the_body |f| {
do avoid_copying_the_body |+f| {
task().spawn_listener(fn~(move f, _po: comm::Port<int>) {
f();
});

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

@ -37,7 +37,7 @@ use local_data_priv::{
*
* These two cases aside, the interface is safe.
*/
pub type LocalDataKey<T: Owned> = &fn(+v: @T);
pub type LocalDataKey<T: Owned> = &fn(v: @T);
/**
* Remove a task-local data value from the table, returning the
@ -62,7 +62,7 @@ pub unsafe fn local_data_get<T: Owned>(
* that value is overwritten (and its destructor is run).
*/
pub unsafe fn local_data_set<T: Owned>(
key: LocalDataKey<T>, +data: @T) {
key: LocalDataKey<T>, data: @T) {
local_set(rt::rust_get_task(), key, data)
}
@ -79,7 +79,7 @@ pub unsafe fn local_data_modify<T: Owned>(
#[test]
pub fn test_tls_multitask() unsafe {
fn my_key(+_x: @~str) { }
fn my_key(_x: @~str) { }
local_data_set(my_key, @~"parent data");
do task::spawn unsafe {
assert local_data_get(my_key).is_none(); // TLS shouldn't carry over.
@ -95,7 +95,7 @@ pub fn test_tls_multitask() unsafe {
#[test]
pub fn test_tls_overwrite() unsafe {
fn my_key(+_x: @~str) { }
fn my_key(_x: @~str) { }
local_data_set(my_key, @~"first data");
local_data_set(my_key, @~"next data"); // Shouldn't leak.
assert *(local_data_get(my_key).get()) == ~"next data";
@ -103,7 +103,7 @@ pub fn test_tls_overwrite() unsafe {
#[test]
pub fn test_tls_pop() unsafe {
fn my_key(+_x: @~str) { }
fn my_key(_x: @~str) { }
local_data_set(my_key, @~"weasel");
assert *(local_data_pop(my_key).get()) == ~"weasel";
// Pop must remove the data from the map.
@ -112,7 +112,7 @@ pub fn test_tls_pop() unsafe {
#[test]
pub fn test_tls_modify() unsafe {
fn my_key(+_x: @~str) { }
fn my_key(_x: @~str) { }
local_data_modify(my_key, |data| {
match data {
Some(@ref val) => fail ~"unwelcome value: " + *val,
@ -136,7 +136,7 @@ pub fn test_tls_crust_automorestack_memorial_bug() unsafe {
// jump over to the rust stack, which causes next_c_sp to get recorded as
// Something within a rust stack segment. Then a subsequent upcall (esp.
// for logging, think vsnprintf) would run on a stack smaller than 1 MB.
fn my_key(+_x: @~str) { }
fn my_key(_x: @~str) { }
do task::spawn {
unsafe { local_data_set(my_key, @~"hax"); }
}
@ -144,9 +144,9 @@ pub fn test_tls_crust_automorestack_memorial_bug() unsafe {
#[test]
pub fn test_tls_multiple_types() unsafe {
fn str_key(+_x: @~str) { }
fn box_key(+_x: @@()) { }
fn int_key(+_x: @int) { }
fn str_key(_x: @~str) { }
fn box_key(_x: @@()) { }
fn int_key(_x: @int) { }
do task::spawn unsafe {
local_data_set(str_key, @~"string data");
local_data_set(box_key, @@());
@ -156,9 +156,9 @@ pub fn test_tls_multiple_types() unsafe {
#[test]
pub fn test_tls_overwrite_multiple_types() {
fn str_key(+_x: @~str) { }
fn box_key(+_x: @@()) { }
fn int_key(+_x: @int) { }
fn str_key(_x: @~str) { }
fn box_key(_x: @@()) { }
fn int_key(_x: @int) { }
do task::spawn unsafe {
local_data_set(str_key, @~"string data");
local_data_set(int_key, @42);
@ -172,9 +172,9 @@ pub fn test_tls_overwrite_multiple_types() {
#[should_fail]
#[ignore(cfg(windows))]
pub fn test_tls_cleanup_on_failure() unsafe {
fn str_key(+_x: @~str) { }
fn box_key(+_x: @@()) { }
fn int_key(+_x: @int) { }
fn str_key(_x: @~str) { }
fn box_key(_x: @@()) { }
fn int_key(_x: @int) { }
local_data_set(str_key, @~"parent data");
local_data_set(box_key, @@());
do task::spawn unsafe { // spawn_linked

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

@ -117,7 +117,7 @@ unsafe fn local_get<T: Owned>(
}
unsafe fn local_set<T: Owned>(
task: *rust_task, key: LocalDataKey<T>, +data: @T) {
task: *rust_task, key: LocalDataKey<T>, data: @T) {
let map = get_task_local_map(task);
// Store key+data as *voids. Data is invisibly referenced once; key isn't.

20
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(+v: *rust_task) -> bool) {
fn taskset_each(tasks: &TaskSet, blk: fn(v: *rust_task) -> bool) {
tasks.each_key(|k| blk(*k))
}
@ -303,8 +303,8 @@ struct TCB {
}
}
fn TCB(me: *rust_task, +tasks: TaskGroupArc, +ancestors: AncestorList,
is_main: bool, +notifier: Option<AutoNotify>) -> TCB {
fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
is_main: bool, notifier: Option<AutoNotify>) -> TCB {
let notifier = move notifier;
notifier.iter(|x| { x.failed = false; });
@ -327,7 +327,7 @@ struct AutoNotify {
}
}
fn AutoNotify(+chan: Chan<Notification>) -> AutoNotify {
fn AutoNotify(chan: Chan<Notification>) -> AutoNotify {
AutoNotify {
notify_chan: chan,
failed: true // Un-set above when taskgroup successfully made.
@ -377,13 +377,13 @@ fn kill_taskgroup(state: TaskGroupInner, me: *rust_task, is_main: bool) {
// see 'None' if Somebody already failed and we got a kill signal.)
if newstate.is_some() {
let group = option::unwrap(move newstate);
for taskset_each(&group.members) |+sibling| {
for taskset_each(&group.members) |sibling| {
// Skip self - killing ourself won't do much good.
if sibling != me {
rt::rust_task_kill_other(sibling);
}
}
for taskset_each(&group.descendants) |+child| {
for taskset_each(&group.descendants) |child| {
assert child != me;
rt::rust_task_kill_other(child);
}
@ -486,7 +486,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
}
}
fn spawn_raw(+opts: TaskOpts, +f: fn~()) {
fn spawn_raw(opts: TaskOpts, +f: fn~()) {
let (child_tg, ancestors, is_main) =
gen_child_taskgroup(opts.linked, opts.supervised);
@ -528,9 +528,9 @@ fn spawn_raw(+opts: TaskOpts, +f: fn~()) {
// (3a) If any of those fails, it leaves all groups, and does nothing.
// (3b) Otherwise it builds a task control structure and puts it in TLS,
// (4) ...and runs the provided body function.
fn make_child_wrapper(child: *rust_task, +child_arc: TaskGroupArc,
+ancestors: AncestorList, is_main: bool,
+notify_chan: Option<Chan<Notification>>,
fn make_child_wrapper(child: *rust_task, child_arc: TaskGroupArc,
ancestors: AncestorList, is_main: bool,
notify_chan: Option<Chan<Notification>>,
+f: fn~()) -> fn~() {
let child_data = ~mut Some((move child_arc, move ancestors));
return fn~(move notify_chan, move child_data, move f) {

10
src/libcore/util.rs
View File

@ -5,25 +5,25 @@ Miscellaneous helpers for common patterns.
*/
// NB: transitionary, de-mode-ing.
#[forbid(deprecated_mode)];
// tjc: re-forbid deprecated modes after snapshot
#[forbid(deprecated_pattern)];
use cmp::Eq;
/// The identity function.
#[inline(always)]
pub pure fn id<T>(+x: T) -> T { move x }
pub pure fn id<T>(x: T) -> T { move x }
/// Ignores a value.
#[inline(always)]
pub pure fn ignore<T>(+_x: T) { }
pub pure fn ignore<T>(_x: T) { }
/// Sets `*ptr` to `new_value`, invokes `op()`, and then restores the
/// original value of `*ptr`.
#[inline(always)]
pub fn with<T: Copy, R>(
ptr: &mut T,
+new_value: T,
new_value: T,
op: &fn() -> R) -> R
{
// NDM: if swap operator were defined somewhat differently,
@ -50,7 +50,7 @@ pub fn swap<T>(x: &mut T, y: &mut T) {
* value, without deinitialising or copying either one.
*/
#[inline(always)]
pub fn replace<T>(dest: &mut T, +src: T) -> T {
pub fn replace<T>(dest: &mut T, src: T) -> T {
let mut tmp <- src;
swap(dest, &mut tmp);
move tmp

96
src/libcore/vec.rs
View File

@ -47,7 +47,7 @@ pub pure fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
* * v - A vector
* * n - The number of elements to reserve space for
*/
pub fn reserve<T>(+v: &mut ~[T], +n: uint) {
pub fn reserve<T>(v: &mut ~[T], n: uint) {
// Only make the (slow) call into the runtime if we have to
if capacity(v) < n {
unsafe {
@ -119,7 +119,7 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
* Creates an immutable vector of size `n_elts` and initializes the elements
* to the value `t`.
*/
pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> ~[T] {
pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> ~[T] {
from_fn(n_elts, |_i| copy t)
}
@ -148,9 +148,9 @@ pub pure fn with_capacity<T>(capacity: uint) -> ~[T] {
*/
#[inline(always)]
pub pure fn build_sized<A>(size: uint,
builder: fn(push: pure fn(+v: A))) -> ~[A] {
builder: fn(push: pure fn(v: A))) -> ~[A] {
let mut vec = with_capacity(size);
builder(|+x| unsafe { vec.push(move x) });
builder(|x| unsafe { vec.push(move x) });
move vec
}
@ -165,7 +165,7 @@ pub pure fn build_sized<A>(size: uint,
* onto the vector being constructed.
*/
#[inline(always)]
pub pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
pub pure fn build<A>(builder: fn(push: pure fn(v: A))) -> ~[A] {
build_sized(4, builder)
}
@ -183,17 +183,17 @@ pub pure fn build<A>(builder: fn(push: pure fn(+v: A))) -> ~[A] {
*/
#[inline(always)]
pub pure fn build_sized_opt<A>(size: Option<uint>,
builder: fn(push: pure fn(+v: A))) -> ~[A] {
builder: fn(push: pure fn(v: A))) -> ~[A] {
build_sized(size.get_default(4), builder)
}
/// Produces a mut vector from an immutable vector.
pub pure fn to_mut<T>(+v: ~[T]) -> ~[mut T] {
pub pure fn to_mut<T>(v: ~[T]) -> ~[mut T] {
unsafe { ::cast::transmute(move v) }
}
/// Produces an immutable vector from a mut vector.
pub pure fn from_mut<T>(+v: ~[mut T]) -> ~[T] {
pub pure fn from_mut<T>(v: ~[mut T]) -> ~[T] {
unsafe { ::cast::transmute(move v) }
}
@ -412,13 +412,13 @@ pub fn shift<T>(v: &mut ~[T]) -> T {
}
/// Prepend an element to the vector
pub fn unshift<T>(v: &mut ~[T], +x: T) {
pub fn unshift<T>(v: &mut ~[T], x: T) {
let mut vv = ~[move x];
*v <-> vv;
v.push_all_move(vv);
}
pub fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) unsafe {
let mut v = move v; // FIXME(#3488)
do as_imm_buf(v) |p, ln| {
@ -431,7 +431,7 @@ pub fn consume<T>(+v: ~[T], f: fn(uint, +v: T)) unsafe {
raw::set_len(&mut v, 0);
}
pub fn consume_mut<T>(+v: ~[mut T], f: fn(uint, +v: T)) {
pub fn consume_mut<T>(v: ~[mut T], f: fn(uint, v: T)) {
consume(vec::from_mut(v), f)
}
@ -468,7 +468,7 @@ pub fn swap_remove<T>(v: &mut ~[T], index: uint) -> T {
/// Append an element to a vector
#[inline(always)]
pub fn push<T>(v: &mut ~[T], +initval: T) {
pub fn push<T>(v: &mut ~[T], initval: T) {
unsafe {
let repr: **raw::VecRepr = ::cast::transmute(copy v);
let fill = (**repr).unboxed.fill;
@ -483,7 +483,7 @@ pub fn push<T>(v: &mut ~[T], +initval: T) {
// This doesn't bother to make sure we have space.
#[inline(always)] // really pretty please
unsafe fn push_fast<T>(+v: &mut ~[T], +initval: T) {
unsafe fn push_fast<T>(v: &mut ~[T], initval: T) {
let repr: **raw::VecRepr = ::cast::transmute(v);
let fill = (**repr).unboxed.fill;
(**repr).unboxed.fill += sys::size_of::<T>();
@ -493,13 +493,13 @@ unsafe fn push_fast<T>(+v: &mut ~[T], +initval: T) {
}
#[inline(never)]
fn push_slow<T>(+v: &mut ~[T], +initval: T) {
fn push_slow<T>(v: &mut ~[T], initval: T) {
reserve_at_least(v, v.len() + 1u);
unsafe { push_fast(v, move initval) }
}
#[inline(always)]
pub fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
pub fn push_all<T: Copy>(v: &mut ~[T], rhs: &[const T]) {
reserve(v, v.len() + rhs.len());
for uint::range(0u, rhs.len()) |i| {
@ -508,7 +508,7 @@ pub fn push_all<T: Copy>(+v: &mut ~[T], rhs: &[const T]) {
}
#[inline(always)]
pub fn push_all_move<T>(v: &mut ~[T], +rhs: ~[T]) {
pub fn push_all_move<T>(v: &mut ~[T], rhs: ~[T]) {
let mut rhs = move rhs; // FIXME(#3488)
reserve(v, v.len() + rhs.len());
unsafe {
@ -573,7 +573,7 @@ pub fn dedup<T: Eq>(v: &mut ~[T]) unsafe {
// Appending
#[inline(always)]
pub pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
pub pure fn append<T: Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] {
let mut v <- lhs;
unsafe {
v.push_all(rhs);
@ -582,14 +582,14 @@ pub pure fn append<T: Copy>(+lhs: ~[T], rhs: &[const T]) -> ~[T] {
}
#[inline(always)]
pub pure fn append_one<T>(+lhs: ~[T], +x: T) -> ~[T] {
pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
let mut v <- lhs;
unsafe { v.push(move x); }
move v
}
#[inline(always)]
pure fn append_mut<T: Copy>(+lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
pure fn append_mut<T: Copy>(lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
to_mut(append(from_mut(lhs), rhs))
}
@ -642,7 +642,7 @@ pub fn grow_fn<T>(v: &mut ~[T], n: uint, op: iter::InitOp<T>) {
* of the vector, expands the vector by replicating `initval` to fill the
* intervening space.
*/
pub fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, +val: T) {
pub fn grow_set<T: Copy>(v: &mut ~[T], index: uint, initval: &T, val: T) {
let l = v.len();
if index >= l { grow(v, index - l + 1u, initval); }
v[index] = move val;
@ -661,7 +661,7 @@ pub pure fn map<T, U>(v: &[T], f: fn(t: &T) -> U) -> ~[U] {
move result
}
pub fn map_consume<T, U>(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] {
pub fn map_consume<T, U>(v: ~[T], f: fn(v: T) -> U) -> ~[U] {
let mut result = ~[];
do consume(move v) |_i, x| {
result.push(f(move x));
@ -758,7 +758,7 @@ pub pure fn connect<T: Copy>(v: &[~[T]], sep: &T) -> ~[T] {
}
/// Reduce a vector from left to right
pub pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
pub pure fn foldl<T: Copy, U>(z: T, v: &[U], p: fn(t: T, u: &U) -> T) -> T {
let mut accum = z;
for each(v) |elt| {
// it should be possible to move accum in, but the liveness analysis
@ -769,7 +769,7 @@ pub pure fn foldl<T: Copy, U>(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T {
}
/// Reduce a vector from right to left
pub pure fn foldr<T, U: Copy>(v: &[T], +z: U, p: fn(t: &T, +u: U) -> U) -> U {
pub pure fn foldr<T, U: Copy>(v: &[T], z: U, p: fn(t: &T, u: U) -> U) -> U {
let mut accum = z;
for rev_each(v) |elt| {
accum = p(elt, accum);
@ -992,7 +992,7 @@ pure fn unzip_slice<T: Copy, U: Copy>(v: &[(T, U)]) -> (~[T], ~[U]) {
* and the i-th element of the second vector contains the second element
* of the i-th tuple of the input vector.
*/
pub pure fn unzip<T,U>(+v: ~[(T, U)]) -> (~[T], ~[U]) {
pub pure fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) {
let mut ts = ~[], us = ~[];
unsafe {
do consume(move v) |_i, p| {
@ -1023,7 +1023,7 @@ pub pure fn zip_slice<T: Copy, U: Copy>(v: &[const T], u: &[const U])
* Returns a vector of tuples, where the i-th tuple contains contains the
* i-th elements from each of the input vectors.
*/
pub pure fn zip<T, U>(+v: ~[T], +u: ~[U]) -> ~[(T, U)] {
pub pure fn zip<T, U>(v: ~[T], u: ~[U]) -> ~[(T, U)] {
let mut v = move v, u = move u; // FIXME(#3488)
let mut i = len(v);
assert i == len(u);
@ -1190,7 +1190,7 @@ pub fn each2<U, T>(v1: &[U], v2: &[T], f: fn(u: &U, t: &T) -> bool) {
* The total number of permutations produced is `len(v)!`. If `v` contains
* repeated elements, then some permutations are repeated.
*/
pure fn each_permutation<T: Copy>(+v: &[T], put: fn(ts: &[T]) -> bool) {
pure fn each_permutation<T: Copy>(v: &[T], put: fn(ts: &[T]) -> bool) {
let ln = len(v);
if ln <= 1 {
put(v);
@ -1435,7 +1435,7 @@ impl<T: Copy> &[const T]: CopyableVector<T> {
pub trait ImmutableVector<T> {
pure fn view(start: uint, end: uint) -> &self/[T];
pure fn foldr<U: Copy>(+z: U, p: fn(t: &T, +u: U) -> U) -> U;
pure fn foldr<U: Copy>(z: U, p: fn(t: &T, u: U) -> U) -> U;
pure fn map<U>(f: fn(t: &T) -> U) -> ~[U];
pure fn mapi<U>(f: fn(uint, t: &T) -> U) -> ~[U];
fn map_r<U>(f: fn(x: &T) -> U) -> ~[U];
@ -1459,7 +1459,7 @@ impl<T> &[T]: ImmutableVector<T> {
}
/// Reduce a vector from right to left
#[inline]
pure fn foldr<U: Copy>(+z: U, p: fn(t: &T, +u: U) -> U) -> U {
pure fn foldr<U: Copy>(z: U, p: fn(t: &T, u: U) -> U) -> U {
foldr(self, z, p)
}
/// Apply a function to each element of a vector and return the results
@ -1582,11 +1582,11 @@ impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
}
pub trait MutableVector<T> {
fn push(&mut self, +t: T);
fn push_all_move(&mut self, +rhs: ~[T]);
fn push(&mut self, t: T);
fn push_all_move(&mut self, rhs: ~[T]);
fn pop(&mut self) -> T;
fn shift(&mut self) -> T;
fn unshift(&mut self, +x: T);
fn unshift(&mut self, x: T);
fn swap_remove(&mut self, index: uint) -> T;
fn truncate(&mut self, newlen: uint);
}
@ -1595,7 +1595,7 @@ pub trait MutableCopyableVector<T: Copy> {
fn push_all(&mut self, rhs: &[const T]);
fn grow(&mut self, n: uint, initval: &T);
fn grow_fn(&mut self, n: uint, op: iter::InitOp<T>);
fn grow_set(&mut self, index: uint, initval: &T, +val: T);
fn grow_set(&mut self, index: uint, initval: &T, val: T);
}
trait MutableEqVector<T: Eq> {
@ -1603,11 +1603,11 @@ trait MutableEqVector<T: Eq> {
}
impl<T> ~[T]: MutableVector<T> {
fn push(&mut self, +t: T) {
fn push(&mut self, t: T) {
push(self, move t);
}
fn push_all_move(&mut self, +rhs: ~[T]) {
fn push_all_move(&mut self, rhs: ~[T]) {
push_all_move(self, move rhs);
}
@ -1619,7 +1619,7 @@ impl<T> ~[T]: MutableVector<T> {
shift(self)
}
fn unshift(&mut self, +x: T) {
fn unshift(&mut self, x: T) {
unshift(self, x)
}
@ -1645,7 +1645,7 @@ impl<T: Copy> ~[T]: MutableCopyableVector<T> {
grow_fn(self, n, op);
}
fn grow_set(&mut self, index: uint, initval: &T, +val: T) {
fn grow_set(&mut self, index: uint, initval: &T, val: T) {
grow_set(self, index, initval, val);
}
}
@ -1717,21 +1717,21 @@ pub mod raw {
* would also make any pointers to it invalid.
*/
#[inline(always)]
pub unsafe fn to_ptr<T>(+v: &[T]) -> *T {
pub unsafe fn to_ptr<T>(v: &[T]) -> *T {
let repr: **SliceRepr = ::cast::transmute(&v);
return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
}
/** see `to_ptr()` */
#[inline(always)]
pub unsafe fn to_const_ptr<T>(+v: &[const T]) -> *const T {
pub unsafe fn to_const_ptr<T>(v: &[const T]) -> *const T {
let repr: **SliceRepr = ::cast::transmute(&v);
return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
}
/** see `to_ptr()` */
#[inline(always)]
pub unsafe fn to_mut_ptr<T>(+v: &[mut T]) -> *mut T {
pub unsafe fn to_mut_ptr<T>(v: &[mut T]) -> *mut T {
let repr: **SliceRepr = ::cast::transmute(&v);
return ::cast::reinterpret_cast(&addr_of(&((**repr).data)));
}
@ -1764,7 +1764,7 @@ pub mod raw {
* is newly allocated.
*/
#[inline(always)]
pub unsafe fn init_elem<T>(v: &[mut T], i: uint, +val: T) {
pub unsafe fn init_elem<T>(v: &[mut T], i: uint, val: T) {
let mut box = Some(move val);
do as_mut_buf(v) |p, _len| {
let mut box2 = None;
@ -1896,7 +1896,7 @@ impl<A> &[A]: iter::ExtendedIter<A> {
}
pub pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) }
pub pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) }
pub pure fn foldl<B>(+b0: B, blk: fn(&B, &A) -> B) -> B {
pub pure fn foldl<B>(b0: B, blk: fn(&B, &A) -> B) -> B {
iter::foldl(&self, move b0, blk)
}
pub pure fn position(f: fn(&A) -> bool) -> Option<uint> {
@ -1910,10 +1910,10 @@ impl<A: Eq> &[A]: iter::EqIter<A> {
}
impl<A: Copy> &[A]: iter::CopyableIter<A> {
pure fn filter_to_vec(pred: fn(+a: A) -> bool) -> ~[A] {
pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A] {
iter::filter_to_vec(&self, pred)
}
pure fn map_to_vec<B>(op: fn(+v: A) -> B) -> ~[B] {
pure fn map_to_vec<B>(op: fn(v: A) -> B) -> ~[B] {
iter::map_to_vec(&self, op)
}
pure fn to_vec() -> ~[A] { iter::to_vec(&self) }
@ -1923,7 +1923,7 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
// iter::flat_map_to_vec(self, op)
// }
pub pure fn find(p: fn(+a: A) -> bool) -> Option<A> {
pub pure fn find(p: fn(a: A) -> bool) -> Option<A> {
iter::find(&self, p)
}
}
@ -1951,7 +1951,7 @@ mod tests {
return if *n % 2u == 1u { Some(*n * *n) } else { None };
}
fn add(+x: uint, y: &uint) -> uint { return x + *y; }
fn add(x: uint, y: &uint) -> uint { return x + *y; }
#[test]
fn test_unsafe_ptrs() {
@ -2193,7 +2193,7 @@ mod tests {
#[test]
fn test_dedup() {
fn case(+a: ~[uint], +b: ~[uint]) {
fn case(a: ~[uint], b: ~[uint]) {
let mut v = a;
v.dedup();
assert(v == b);
@ -2323,7 +2323,7 @@ mod tests {
#[test]
fn test_foldl2() {
fn sub(+a: int, b: &int) -> int {
fn sub(a: int, b: &int) -> int {
a - *b
}
let mut v = ~[1, 2, 3, 4];
@ -2333,7 +2333,7 @@ mod tests {
#[test]
fn test_foldr() {
fn sub(a: &int, +b: int) -> int {
fn sub(a: &int, b: int) -> int {
*a - b
}
let mut v = ~[1, 2, 3, 4];

2
src/libstd/getopts.rs
View File

@ -232,7 +232,7 @@ type Result = result::Result<Matches, Fail_>;
*/
fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
let n_opts = vec::len::<Opt>(opts);
fn f(_x: uint) -> ~[Optval] { return ~[]; }
fn f(+_x: uint) -> ~[Optval] { return ~[]; }
let vals = vec::to_mut(vec::from_fn(n_opts, f));
let mut free: ~[~str] = ~[];
let l = vec::len(args);

8
src/libstd/net_tcp.rs
View File

@ -763,7 +763,7 @@ impl TcpSocket {
/// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
impl TcpSocketBuf: io::Reader {
fn read(buf: &[mut u8], len: uint) -> uint {
fn read(buf: &[mut u8], +len: uint) -> uint {
// Loop until our buffer has enough data in it for us to read from.
while self.data.buf.len() < len {
let read_result = read(&self.data.sock, 0u);
@ -799,13 +799,13 @@ impl TcpSocketBuf: io::Reader {
let mut bytes = ~[0];
if self.read(bytes, 1u) == 0 { fail } else { bytes[0] as int }
}
fn unread_byte(amt: int) {
fn unread_byte(+amt: int) {
self.data.buf.unshift(amt as u8);
}
fn eof() -> bool {
false // noop
}
fn seek(dist: int, seek: io::SeekStyle) {
fn seek(+dist: int, +seek: io::SeekStyle) {
log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
// noop
}
@ -827,7 +827,7 @@ impl TcpSocketBuf: io::Writer {
err_data.err_name, err_data.err_msg));
}
}
fn seek(dist: int, seek: io::SeekStyle) {
fn seek(+dist: int, +seek: io::SeekStyle) {
log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
// noop
}

2
src/libstd/net_url.rs
View File

@ -735,7 +735,7 @@ impl Url : Eq {
}
impl Url: IterBytes {
pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
unsafe { self.to_str() }.iter_bytes(lsb0, f)
}
}

4
src/libstd/rope.rs
View File

@ -379,7 +379,7 @@ Section: Iterating
* `true` If execution proceeded correctly, `false` if it was interrupted,
* that is if `it` returned `false` at any point.
*/
pub fn loop_chars(rope: Rope, it: fn(char) -> bool) -> bool {
pub fn loop_chars(rope: Rope, it: fn(+c: char) -> bool) -> bool {
match (rope) {
node::Empty => return true,
node::Content(x) => return node::loop_chars(x, it)
@ -1037,7 +1037,7 @@ mod node {
return result;
}
pub fn loop_chars(node: @Node, it: fn(char) -> bool) -> bool {
pub fn loop_chars(node: @Node, it: fn(+c: char) -> bool) -> bool {
return loop_leaves(node,|leaf| {
str::all_between(*leaf.content,
leaf.byte_offset,

3
src/libstd/std.rc
View File

@ -18,6 +18,9 @@ not required in or otherwise suitable for the core library.
#[no_core];
// tjc: Added legacy_modes back in because it still uses + mode.
// Remove once + mode gets expunged from std.
#[legacy_modes];
#[legacy_exports];
#[allow(vecs_implicitly_copyable)];

8
src/rustc/middle/lint.rs
View File

@ -683,8 +683,12 @@ fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
mode_to_str(arg_ast.mode));
match arg_ast.mode {
ast::expl(ast::by_copy) => {
// This should warn, but we can't yet
// since it's still used. -- tjc
if !tcx.legacy_modes {
tcx.sess.span_lint(
deprecated_mode, id, id, span,
fmt!("argument %d uses by-copy mode",
counter));
}
}
ast::expl(_) => {

2
src/test/bench/graph500-bfs.rs
View File

@ -251,7 +251,7 @@ fn pbfs(&&graph: arc::ARC<graph>, key: node_id) -> bfs_result {
colors = do par::mapi_factory(*color_vec) {
let colors = arc::clone(&color);
let graph = arc::clone(&graph);
fn~(+i: uint, +c: color) -> color {
fn~(i: uint, c: color) -> color {
let c : color = c;
let colors = arc::get(&colors);
let graph = arc::get(&graph);