From 3023bd872949ce4ba45e13dbcd30d6b98963d0ed Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Tue, 25 Sep 2012 18:27:45 -0700 Subject: Demode dvec --- src/libstd/smallintmap.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/libstd/smallintmap.rs') diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 8ce1ebde127..5fc8ead59fd 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -132,7 +132,7 @@ impl SmallIntMap: map::Map { } impl SmallIntMap: ops::Index { - pure fn index(&&key: uint) -> V { + pure fn index(+key: uint) -> V { unsafe { get(self, key) } -- cgit 1.4.1-3-g733a5 From bc9efaad9c978f71bd7ac2c91efbc957e25d43fb Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Fri, 28 Sep 2012 00:22:18 -0700 Subject: std: Eliminate deprecated patterns --- src/libstd/arc.rs | 1 - src/libstd/arena.rs | 1 - src/libstd/base64.rs | 1 - src/libstd/bitv.rs | 61 ++++++++++++++++++++++---------------------- src/libstd/cell.rs | 1 - src/libstd/cmp.rs | 1 - src/libstd/comm.rs | 1 - src/libstd/dbg.rs | 1 - src/libstd/deque.rs | 3 +-- src/libstd/fun_treemap.rs | 15 +++++------ src/libstd/getopts.rs | 29 ++++++++++----------- src/libstd/json.rs | 23 ++++++++--------- src/libstd/list.rs | 13 +++++----- src/libstd/map.rs | 3 +-- src/libstd/md4.rs | 1 - src/libstd/net_ip.rs | 17 ++++++------ src/libstd/net_tcp.rs | 34 ++++++++++++------------ src/libstd/net_url.rs | 3 +-- src/libstd/prettyprint.rs | 1 - src/libstd/prettyprint2.rs | 1 - src/libstd/rope.rs | 17 ++++++------ src/libstd/serialization.rs | 4 +-- src/libstd/serialization2.rs | 11 ++++---- src/libstd/sha1.rs | 1 - src/libstd/smallintmap.rs | 5 ++-- src/libstd/sort.rs | 1 - src/libstd/std.rc | 1 + src/libstd/sync.rs | 1 - src/libstd/tempfile.rs | 1 - src/libstd/term.rs | 5 ++-- src/libstd/test.rs | 27 ++++++++++---------- src/libstd/time.rs | 3 +-- src/libstd/timer.rs | 1 - src/libstd/treemap.rs | 1 - src/libstd/unicode.rs | 1 - src/libstd/uv_global_loop.rs | 1 - src/libstd/uv_iotask.rs | 3 +-- 37 files changed, 130 insertions(+), 165 deletions(-) (limited to 'src/libstd/smallintmap.rs') diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs index 1f26822ed9f..a4d19b110d7 100644 --- a/src/libstd/arc.rs +++ b/src/libstd/arc.rs @@ -1,6 +1,5 @@ // NB: transitionary, de-mode-ing. #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /** * Concurrency-enabled mechanisms for sharing mutable and/or immutable state * between tasks. diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs index fbe9a2ddae6..de3c5774bfe 100644 --- a/src/libstd/arena.rs +++ b/src/libstd/arena.rs @@ -23,7 +23,6 @@ // to waste time running the destructors of POD. #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; export Arena, arena_with_size; diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index 995910e635d..9bad4d39750 100644 --- a/src/libstd/base64.rs +++ b/src/libstd/base64.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use io::Reader; pub trait ToBase64 { diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index 0ff0c0b6457..33065fffd03 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use vec::{to_mut, from_elem}; @@ -241,22 +240,22 @@ priv impl Bitv { self.die(); } match self.rep { - Small(s) => match other.rep { - Small(s1) => match op { - Union => s.union(s1, self.nbits), - Intersect => s.intersect(s1, self.nbits), - Assign => s.become(s1, self.nbits), - Difference => s.difference(s1, self.nbits) + Small(ref s) => match other.rep { + Small(ref s1) => match op { + Union => s.union(*s1, self.nbits), + Intersect => s.intersect(*s1, self.nbits), + Assign => s.become(*s1, self.nbits), + Difference => s.difference(*s1, self.nbits) }, Big(_) => self.die() }, - Big(s) => match other.rep { + Big(ref s) => match other.rep { Small(_) => self.die(), - Big(s1) => match op { - Union => s.union(s1, self.nbits), - Intersect => s.intersect(s1, self.nbits), - Assign => s.become(s1, self.nbits), - Difference => s.difference(s1, self.nbits) + Big(ref s1) => match op { + Union => s.union(*s1, self.nbits), + Intersect => s.intersect(*s1, self.nbits), + Assign => s.become(*s1, self.nbits), + Difference => s.difference(*s1, self.nbits) } } } @@ -297,10 +296,10 @@ impl Bitv { #[inline(always)] fn clone() -> ~Bitv { ~match self.rep { - Small(b) => { + Small(ref b) => { Bitv{nbits: self.nbits, rep: Small(~SmallBitv{bits: b.bits})} } - Big(b) => { + Big(ref b) => { let st = to_mut(from_elem(self.nbits / uint_bits + 1, 0)); let len = st.len(); for uint::range(0, len) |i| { st[i] = b.storage[i]; }; @@ -314,8 +313,8 @@ impl Bitv { pure fn get(i: uint) -> bool { assert (i < self.nbits); match self.rep { - Big(b) => b.get(i), - Small(s) => s.get(i) + Big(ref b) => b.get(i), + Small(ref s) => s.get(i) } } @@ -328,8 +327,8 @@ impl Bitv { fn set(i: uint, x: bool) { assert (i < self.nbits); match self.rep { - Big(b) => b.set(i, x), - Small(s) => s.set(i, x) + Big(ref b) => b.set(i, x), + Small(ref s) => s.set(i, x) } } @@ -343,12 +342,12 @@ impl Bitv { fn equal(v1: Bitv) -> bool { if self.nbits != v1.nbits { return false; } match self.rep { - Small(b) => match v1.rep { - Small(b1) => b.equals(b1, self.nbits), + Small(ref b) => match v1.rep { + Small(ref b1) => b.equals(*b1, self.nbits), _ => false }, - Big(s) => match v1.rep { - Big(s1) => s.equals(s1, self.nbits), + Big(ref s) => match v1.rep { + Big(ref s1) => s.equals(*s1, self.nbits), Small(_) => return false } } @@ -358,8 +357,8 @@ impl Bitv { #[inline(always)] fn clear() { match self.rep { - Small(b) => b.clear(), - Big(s) => for s.each_storage() |w| { w = 0u } + Small(ref b) => b.clear(), + Big(ref s) => for s.each_storage() |w| { w = 0u } } } @@ -367,16 +366,16 @@ impl Bitv { #[inline(always)] fn set_all() { match self.rep { - Small(b) => b.set_all(), - Big(s) => for s.each_storage() |w| { w = !0u } } + Small(ref b) => b.set_all(), + Big(ref s) => for s.each_storage() |w| { w = !0u } } } /// Invert all bits #[inline(always)] fn invert() { match self.rep { - Small(b) => b.invert(), - Big(s) => for s.each_storage() |w| { w = !w } } + Small(ref b) => b.invert(), + Big(ref s) => for s.each_storage() |w| { w = !w } } } /** @@ -395,7 +394,7 @@ impl Bitv { #[inline(always)] fn is_true() -> bool { match self.rep { - Small(b) => b.is_true(self.nbits), + Small(ref b) => b.is_true(self.nbits), _ => { for self.each() |i| { if !i { return false; } } true @@ -415,7 +414,7 @@ impl Bitv { /// Returns true if all bits are 0 fn is_false() -> bool { match self.rep { - Small(b) => b.is_false(self.nbits), + Small(ref b) => b.is_false(self.nbits), Big(_) => { for self.each() |i| { if i { return false; } } true diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index bc16aa2e03e..4ef695f4198 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /// A dynamic, mutable location. /// /// Similar to a mutable option type, but friendlier. diff --git a/src/libstd/cmp.rs b/src/libstd/cmp.rs index 52c50a39f25..2ec0bf41675 100644 --- a/src/libstd/cmp.rs +++ b/src/libstd/cmp.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /// Additional general-purpose comparison functionality. const fuzzy_epsilon: float = 1.0e-6; diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs index e2d4646d670..58958d6115e 100644 --- a/src/libstd/comm.rs +++ b/src/libstd/comm.rs @@ -6,7 +6,6 @@ Higher level communication abstractions. // NB: transitionary, de-mode-ing. #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use pipes::{Channel, Recv, Chan, Port, Selectable}; diff --git a/src/libstd/dbg.rs b/src/libstd/dbg.rs index ac343053bed..26b2a02ec9c 100644 --- a/src/libstd/dbg.rs +++ b/src/libstd/dbg.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; //! Unsafe debugging functions for inspecting values. use cast::reinterpret_cast; diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 8506bd5f6fc..515f033b1f1 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -1,6 +1,5 @@ //! A deque. Untested as of yet. Likely buggy #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; #[forbid(non_camel_case_types)]; use option::{Some, None}; @@ -46,7 +45,7 @@ fn create() -> Deque { move rv } fn get(elts: &DVec>, i: uint) -> T { - match (*elts).get_elt(i) { Some(t) => t, _ => fail } + match (*elts).get_elt(i) { Some(move t) => t, _ => fail } } type Repr = {mut nelts: uint, diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs index 778a62eebbe..6388e8983d2 100644 --- a/src/libstd/fun_treemap.rs +++ b/src/libstd/fun_treemap.rs @@ -1,5 +1,4 @@ #[warn(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /*! * A functional key,value store that works on anything. @@ -37,7 +36,7 @@ fn insert(m: Treemap, +k: K, +v: V) -> Treemap { @match m { @Empty => Node(@k, @v, @Empty, @Empty), - @Node(@kk, vv, left, right) => { + @Node(@copy kk, vv, left, right) => { if k < kk { Node(@kk, vv, insert(left, k, v), right) } else if k == kk { @@ -51,10 +50,10 @@ fn insert(m: Treemap, +k: K, +v: V) fn find(m: Treemap, +k: K) -> Option { match *m { Empty => None, - Node(@kk, @v, left, right) => { - if k == kk { + Node(@ref kk, @copy v, left, right) => { + if k == *kk { Some(v) - } else if k < kk { find(left, move k) } else { find(right, move k) } + } else if k < *kk { find(left, move k) } else { find(right, move k) } } } } @@ -68,11 +67,9 @@ fn traverse(m: Treemap, f: fn((&K), (&V))) { matches to me, so I changed it. but that may be a de-optimization -- tjc */ - Node(@k, @v, left, right) => { - // copy v to make aliases work out - let v1 = v; + Node(@ref k, @ref v, left, right) => { traverse(left, f); - f(&k, &v1); + f(k, v); traverse(right, f); } } diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 7a47db8a7f0..3106ed953b1 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -63,7 +63,6 @@ */ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::cmp::Eq; use core::result::{Err, Ok}; @@ -110,9 +109,9 @@ fn mkname(nm: &str) -> Name { impl Name : Eq { pure fn eq(other: &Name) -> bool { match self { - Long(e0a) => { + Long(ref e0a) => { match (*other) { - Long(e0b) => e0a == e0b, + Long(ref e0b) => e0a == e0b, _ => false } } @@ -177,7 +176,7 @@ fn is_arg(arg: &str) -> bool { fn name_str(nm: &Name) -> ~str { return match *nm { Short(ch) => str::from_char(ch), - Long(s) => s + Long(copy s) => s }; } @@ -200,12 +199,12 @@ enum Fail_ { /// Convert a `fail_` enum into an error string fn fail_str(+f: Fail_) -> ~str { return match f { - ArgumentMissing(nm) => ~"Argument to option '" + nm + ~"' missing.", - UnrecognizedOption(nm) => ~"Unrecognized option: '" + nm + ~"'.", - OptionMissing(nm) => ~"Required option '" + nm + ~"' missing.", - OptionDuplicated(nm) => ~"Option '" + nm + ~"' given more than once.", - UnexpectedArgument(nm) => { - ~"Option " + nm + ~" does not take an argument." + ArgumentMissing(ref nm) => ~"Argument to option '" + *nm + ~"' missing.", + UnrecognizedOption(ref nm) => ~"Unrecognized option: '" + *nm + ~"'.", + OptionMissing(ref nm) => ~"Required option '" + *nm + ~"' missing.", + OptionDuplicated(ref nm) => ~"Option '" + *nm + ~"' given more than once.", + UnexpectedArgument(ref nm) => { + ~"Option " + *nm + ~" does not take an argument." } }; } @@ -382,7 +381,7 @@ fn opts_present(+mm: Matches, names: &[~str]) -> bool { * argument */ fn opt_str(+mm: Matches, nm: &str) -> ~str { - return match opt_val(mm, nm) { Val(s) => s, _ => fail }; + return match opt_val(mm, nm) { Val(copy s) => s, _ => fail }; } /** @@ -394,7 +393,7 @@ fn opt_str(+mm: Matches, nm: &str) -> ~str { fn opts_str(+mm: Matches, names: &[~str]) -> ~str { for vec::each(names) |nm| { match opt_val(mm, *nm) { - Val(s) => return s, + Val(copy s) => return s, _ => () } } @@ -411,7 +410,7 @@ fn opts_str(+mm: Matches, names: &[~str]) -> ~str { fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] { let mut acc: ~[~str] = ~[]; for vec::each(opt_vals(mm, nm)) |v| { - match *v { Val(s) => acc.push(s), _ => () } + match *v { Val(copy s) => acc.push(s), _ => () } } return acc; } @@ -420,7 +419,7 @@ fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] { fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> { let vals = opt_vals(mm, nm); if vec::len::(vals) == 0u { return None::<~str>; } - return match vals[0] { Val(s) => Some::<~str>(s), _ => None::<~str> }; + return match vals[0] { Val(copy s) => Some::<~str>(s), _ => None::<~str> }; } @@ -434,7 +433,7 @@ fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> { fn opt_default(+mm: Matches, nm: &str, def: &str) -> Option<~str> { let vals = opt_vals(mm, nm); if vec::len::(vals) == 0u { return None::<~str>; } - return match vals[0] { Val(s) => Some::<~str>(s), + return match vals[0] { Val(copy s) => Some::<~str>(s), _ => Some::<~str>(str::from_slice(def)) } } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 29535c62b5e..9e53febb85f 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1,7 +1,6 @@ // Rust JSON serialization library // Copyright (c) 2011 Google Inc. #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; #[forbid(non_camel_case_types)]; //! json serialization @@ -252,7 +251,7 @@ pub impl PrettySerializer: serialization2::Serializer { pub fn to_serializer(ser: &S, json: &Json) { match *json { Number(f) => ser.emit_float(f), - String(s) => ser.emit_str(s), + String(ref s) => ser.emit_str(*s), Boolean(b) => ser.emit_bool(b), List(v) => { do ser.emit_vec(v.len()) || { @@ -261,7 +260,7 @@ pub fn to_serializer(ser: &S, json: &Json) { } } } - Object(o) => { + Object(ref o) => { do ser.emit_rec || { let mut idx = 0; for o.each |key, value| { @@ -866,8 +865,8 @@ impl Json : Eq { match self { Number(f0) => match *other { Number(f1) => f0 == f1, _ => false }, - String(s0) => - match *other { String(s1) => s0 == s1, _ => false }, + String(ref s0) => + match *other { String(ref s1) => s0 == s1, _ => false }, Boolean(b0) => match *other { Boolean(b1) => b0 == b1, _ => false }, Null => @@ -910,10 +909,10 @@ impl Json : Ord { } } - String(s0) => { + String(ref s0) => { match *other { Number(_) => false, - String(s1) => s0 < s1, + String(ref s1) => s0 < s1, Boolean(_) | List(_) | Object(_) | Null => true } } @@ -934,10 +933,10 @@ impl Json : Ord { } } - Object(d0) => { + Object(ref d0) => { match *other { Number(_) | String(_) | Boolean(_) | List(_) => false, - Object(d1) => { + Object(ref d1) => { unsafe { let mut d0_flat = ~[]; let mut d1_flat = ~[]; @@ -1065,7 +1064,7 @@ impl @~str: ToJson { impl (A, B): ToJson { fn to_json() -> Json { match self { - (a, b) => { + (ref a, ref b) => { List(~[a.to_json(), b.to_json()]) } } @@ -1075,7 +1074,7 @@ impl (A, B): ToJson { impl (A, B, C): ToJson { fn to_json() -> Json { match self { - (a, b, c) => { + (ref a, ref b, ref c) => { List(~[a.to_json(), b.to_json(), c.to_json()]) } } @@ -1112,7 +1111,7 @@ impl Option: ToJson { fn to_json() -> Json { match self { None => Null, - Some(value) => value.to_json() + Some(ref value) => value.to_json() } } } diff --git a/src/libstd/list.rs b/src/libstd/list.rs index d8f7edada6a..1568c6c099f 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -1,6 +1,5 @@ //! A standard linked list #[warn(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::cmp::Eq; use core::option; @@ -47,8 +46,8 @@ fn find(ls: @List, f: fn((&T)) -> bool) -> Option { let mut ls = ls; loop { ls = match *ls { - Cons(hd, tl) => { - if f(&hd) { return Some(hd); } + Cons(ref hd, tl) => { + if f(hd) { return Some(*hd); } tl } Nil => return None @@ -95,7 +94,7 @@ pure fn tail(ls: @List) -> @List { /// Returns the first element of a list pure fn head(ls: @List) -> T { match *ls { - Cons(hd, _) => hd, + Cons(copy hd, _) => hd, // makes me sad _ => fail ~"head invoked on empty list" } @@ -105,7 +104,7 @@ pure fn head(ls: @List) -> T { pure fn append(l: @List, m: @List) -> @List { match *l { Nil => return m, - Cons(x, xs) => { + Cons(copy x, xs) => { let rest = append(xs, m); return @Cons(x, rest); } @@ -151,9 +150,9 @@ fn each(l: @List, f: fn((&T)) -> bool) { impl List : Eq { pure fn eq(other: &List) -> bool { match self { - Cons(e0a, e1a) => { + Cons(ref e0a, e1a) => { match (*other) { - Cons(e0b, e1b) => e0a == e0b && e1a == e1b, + Cons(ref e0b, e1b) => e0a == e0b && e1a == e1b, _ => false } } diff --git a/src/libstd/map.rs b/src/libstd/map.rs index 06df5a9e8ae..fce75cbda75 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -1,7 +1,6 @@ //! A map type #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use io::WriterUtil; use to_str::ToStr; @@ -404,7 +403,7 @@ fn hash_from_vec( let map = HashMap(); for vec::each(items) |item| { match *item { - (key, value) => { + (copy key, copy value) => { map.insert(key, value); } } diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index 6de6ea8b16c..581beb78bdc 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; pub fn md4(msg: &[u8]) -> {a: u32, b: u32, c: u32, d: u32} { // subtle: if orig_len is merely uint, then the code below diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 347f2b271a1..ad4eb9a0fa6 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -1,6 +1,5 @@ //! Types/fns concerning Internet Protocol (IP), versions 4 & 6 #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use iotask = uv::iotask::IoTask; use interact = uv::iotask::interact; @@ -48,15 +47,15 @@ type ParseAddrErr = { */ fn format_addr(ip: &IpAddr) -> ~str { match *ip { - Ipv4(addr) => unsafe { - let result = uv_ip4_name(&addr); + Ipv4(ref addr) => unsafe { + let result = uv_ip4_name(addr); if result == ~"" { fail ~"failed to convert inner sockaddr_in address to str" } result }, - Ipv6(addr) => unsafe { - let result = uv_ip6_name(&addr); + Ipv6(ref addr) => unsafe { + let result = uv_ip6_name(addr); if result == ~"" { fail ~"failed to convert inner sockaddr_in address to str" } @@ -136,8 +135,8 @@ mod v4 { */ fn parse_addr(ip: &str) -> IpAddr { match try_parse_addr(ip) { - result::Ok(addr) => copy(addr), - result::Err(err_data) => fail err_data.err_msg + result::Ok(copy addr) => addr, + result::Err(ref err_data) => fail err_data.err_msg } } // the simple, old style numberic representation of @@ -223,8 +222,8 @@ mod v6 { */ fn parse_addr(ip: &str) -> IpAddr { match try_parse_addr(ip) { - result::Ok(addr) => copy(addr), - result::Err(err_data) => fail err_data.err_msg + result::Ok(copy addr) => addr, + result::Err(copy err_data) => fail err_data.err_msg } } fn try_parse_addr(ip: &str) -> result::Result { diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index a0ba8aae3f1..011c7e6a0c7 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -168,7 +168,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint, ptr::addr_of((*socket_data_ptr).connect_req); let addr_str = ip::format_addr(&input_ip); let connect_result = match input_ip { - ip::Ipv4(addr) => { + ip::Ipv4(ref addr) => { // have to "recreate" the sockaddr_in/6 // since the ip_addr discards the port // info.. should probably add an additional @@ -233,7 +233,7 @@ fn connect(+input_ip: ip::IpAddr, port: uint, log(debug, ~"tcp::connect - received success on result_po"); result::Ok(TcpSocket(socket_data)) } - ConnFailure(err_data) => { + ConnFailure(ref err_data) => { core::comm::recv(closed_signal_po); log(debug, ~"tcp::connect - received failure on result_po"); // still have to free the malloc'd stream handle.. @@ -535,7 +535,7 @@ fn accept(new_conn: TcpNewConnection) } // UNSAFE LIBUV INTERACTION END match core::comm::recv(result_po) { - Some(err_data) => result::Err(err_data), + Some(copy err_data) => result::Err(err_data), None => result::Ok(TcpSocket(client_socket_data)) } } @@ -623,13 +623,13 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint, server_data_ptr); let addr_str = ip::format_addr(&loc_ip); let bind_result = match loc_ip { - ip::Ipv4(addr) => { + ip::Ipv4(ref addr) => { log(debug, fmt!("addr: %?", addr)); let in_addr = uv::ll::ip4_addr(addr_str, port as int); uv::ll::tcp_bind(server_stream_ptr, ptr::addr_of(in_addr)) } - ip::Ipv6(addr) => { + ip::Ipv6(ref addr) => { log(debug, fmt!("addr: %?", addr)); let in_addr = uv::ll::ip6_addr(addr_str, port as int); uv::ll::tcp_bind6(server_stream_ptr, @@ -666,7 +666,7 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint, setup_ch.recv() }; match setup_result { - Some(err_data) => { + Some(ref err_data) => { do iotask::interact(iotask) |loop_ptr| unsafe { log(debug, fmt!("tcp::listen post-kill recv hl interact %?", loop_ptr)); @@ -703,7 +703,7 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint, stream_closed_po.recv(); match kill_result { // some failure post bind/listen - Some(err_data) => result::Err(GenericListenErr(err_data.err_name, + Some(ref err_data) => result::Err(GenericListenErr(err_data.err_name, err_data.err_msg)), // clean exit None => result::Ok(()) @@ -884,7 +884,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint) Some(core::comm::recv(result::get(&rs_result))) }; log(debug, ~"tcp::read after recv_timeout"); - match read_result { + match move read_result { None => { log(debug, ~"tcp::read: timed out.."); let err_data = { @@ -894,7 +894,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint) read_stop_common_impl(socket_data); result::Err(err_data) } - Some(data_result) => { + Some(move data_result) => { log(debug, ~"tcp::read got data"); read_stop_common_impl(socket_data); data_result @@ -924,7 +924,7 @@ fn read_stop_common_impl(socket_data: *TcpSocketData) -> } }; match core::comm::recv(stop_po) { - Some(err_data) => result::Err(err_data.to_tcp_err()), + Some(ref err_data) => result::Err(err_data.to_tcp_err()), None => result::Ok(()) } } @@ -954,7 +954,7 @@ fn read_start_common_impl(socket_data: *TcpSocketData) } }; match core::comm::recv(start_po) { - Some(err_data) => result::Err(err_data.to_tcp_err()), + Some(ref err_data) => result::Err(err_data.to_tcp_err()), None => result::Ok((*socket_data).reader_po) } } @@ -1001,7 +1001,7 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData, // aftermath, so we don't have to sit here blocking. match core::comm::recv(result_po) { TcpWriteSuccess => result::Ok(()), - TcpWriteError(err_data) => result::Err(err_data.to_tcp_err()) + TcpWriteError(ref err_data) => result::Err(err_data.to_tcp_err()) } } @@ -1530,8 +1530,8 @@ mod test { log(debug, ~"SERVER: successfully accepted"+ ~"connection!"); let received_req_bytes = read(&sock, 0u); - match received_req_bytes { - result::Ok(data) => { + match move received_req_bytes { + result::Ok(move data) => { log(debug, ~"SERVER: got REQ str::from_bytes.."); log(debug, fmt!("SERVER: REQ data len: %?", vec::len(data))); @@ -1542,7 +1542,7 @@ mod test { log(debug, ~"SERVER: after write.. die"); core::comm::send(kill_ch, None); } - result::Err(err_data) => { + result::Err(move err_data) => { log(debug, fmt!("SERVER: error recvd: %s %s", err_data.err_name, err_data.err_msg)); core::comm::send(kill_ch, Some(err_data)); @@ -1560,9 +1560,9 @@ mod test { // err check on listen_result if result::is_err(&listen_result) { match result::get_err(&listen_result) { - GenericListenErr(name, msg) => { + GenericListenErr(ref name, ref msg) => { fail fmt!("SERVER: exited abnormally name %s msg %s", - name, msg); + *name, *msg); } AccessDenied => { fail ~"SERVER: exited abnormally, got access denied.."; diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index 33e657c390b..00226c4e81e 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -1,6 +1,5 @@ //! Types/fns concerning URLs (see RFC 3986) #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::cmp::Eq; use map::HashMap; @@ -661,7 +660,7 @@ fn from_str(rawurl: &str) -> result::Result { impl Url : FromStr { static fn from_str(s: &str) -> Option { match from_str(s) { - Ok(url) => Some(url), + Ok(move url) => Some(url), Err(_) => None } } diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs index fa4c41dfa13..bc528800666 100644 --- a/src/libstd/prettyprint.rs +++ b/src/libstd/prettyprint.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use io::Writer; use io::WriterUtil; diff --git a/src/libstd/prettyprint2.rs b/src/libstd/prettyprint2.rs index c0e76662bcb..325d240eb57 100644 --- a/src/libstd/prettyprint2.rs +++ b/src/libstd/prettyprint2.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use io::Writer; use io::WriterUtil; diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 4680448e275..1d88b89277d 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -24,7 +24,6 @@ */ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /// The type of ropes. type Rope = node::Root; @@ -738,14 +737,14 @@ mod node { //FIXME (#2744): Could we do this without the pattern-matching? match (*node) { Leaf(y) => return y.byte_len, - Concat(y) => return y.byte_len + Concat(ref y) => return y.byte_len } } pure fn char_len(node: @Node) -> uint { match (*node) { Leaf(y) => return y.char_len, - Concat(y) => return y.char_len + Concat(ref y) => return y.char_len } } @@ -835,7 +834,7 @@ mod node { fn flatten(node: @Node) -> @Node unsafe { match (*node) { Leaf(_) => return node, - Concat(x) => { + Concat(ref x) => { return @Leaf({ byte_offset: 0u, byte_len: x.byte_len, @@ -913,7 +912,7 @@ mod node { char_len: char_len, content: x.content}); } - node::Concat(x) => { + node::Concat(ref x) => { let left_len: uint = node::byte_len(x.left); if byte_offset <= left_len { if byte_offset + byte_len <= left_len { @@ -976,7 +975,7 @@ mod node { char_len: char_len, content: x.content}); } - node::Concat(x) => { + node::Concat(ref x) => { if char_offset == 0u && char_len == x.char_len {return node;} let left_len : uint = node::char_len(x.left); if char_offset <= left_len { @@ -1015,7 +1014,7 @@ mod node { fn height(node: @Node) -> uint { match (*node) { Leaf(_) => return 0u, - Concat(x) => return x.height + Concat(ref x) => return x.height } } @@ -1067,7 +1066,7 @@ mod node { loop { match (*current) { Leaf(x) => return it(x), - Concat(x) => if loop_leaves(x.left, it) { //non tail call + Concat(ref x) => if loop_leaves(x.left, it) { //non tail call current = x.right; //tail call } else { return false; @@ -1134,7 +1133,7 @@ mod node { let current = it.stack[it.stackpos]; it.stackpos -= 1; match (*current) { - Concat(x) => { + Concat(ref x) => { it.stackpos += 1; it.stack[it.stackpos] = x.right; it.stackpos += 1; diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs index af581ba4958..a385924e846 100644 --- a/src/libstd/serialization.rs +++ b/src/libstd/serialization.rs @@ -245,9 +245,9 @@ fn serialize_Option(s: S, v: Option, st: fn(T)) { None => do s.emit_enum_variant(~"none", 0u, 0u) { }, - Some(v) => do s.emit_enum_variant(~"some", 1u, 1u) { + Some(ref v) => do s.emit_enum_variant(~"some", 1u, 1u) { do s.emit_enum_variant_arg(0u) { - st(v) + st(*v) } } } diff --git a/src/libstd/serialization2.rs b/src/libstd/serialization2.rs index 81941627ef6..09954affc21 100644 --- a/src/libstd/serialization2.rs +++ b/src/libstd/serialization2.rs @@ -5,7 +5,6 @@ Core serialization interfaces. */ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; #[forbid(non_camel_case_types)]; pub trait Serializer { @@ -235,7 +234,7 @@ pub impl Option: Serializable { None => do s.emit_enum_variant(~"none", 0u, 0u) { }, - Some(v) => do s.emit_enum_variant(~"some", 1u, 1u) { + Some(ref v) => do s.emit_enum_variant(~"some", 1u, 1u) { s.emit_enum_variant_arg(0u, || v.serialize(s)) } } @@ -261,7 +260,7 @@ pub impl< > (T0, T1): Serializable { fn serialize(&self, s: &S) { match *self { - (t0, t1) => { + (ref t0, ref t1) => { do s.emit_tup(2) { s.emit_tup_elt(0, || t0.serialize(s)); s.emit_tup_elt(1, || t1.serialize(s)); @@ -287,7 +286,7 @@ pub impl< > (T0, T1, T2): Serializable { fn serialize(&self, s: &S) { match *self { - (t0, t1, t2) => { + (ref t0, ref t1, ref t2) => { do s.emit_tup(3) { s.emit_tup_elt(0, || t0.serialize(s)); s.emit_tup_elt(1, || t1.serialize(s)); @@ -316,7 +315,7 @@ pub impl< > (T0, T1, T2, T3): Serializable { fn serialize(&self, s: &S) { match *self { - (t0, t1, t2, t3) => { + (ref t0, ref t1, ref t2, ref t3) => { do s.emit_tup(4) { s.emit_tup_elt(0, || t0.serialize(s)); s.emit_tup_elt(1, || t1.serialize(s)); @@ -348,7 +347,7 @@ pub impl< > (T0, T1, T2, T3, T4): Serializable { fn serialize(&self, s: &S) { match *self { - (t0, t1, t2, t3, t4) => { + (ref t0, ref t1, ref t2, ref t3, ref t4) => { do s.emit_tup(5) { s.emit_tup_elt(0, || t0.serialize(s)); s.emit_tup_elt(1, || t1.serialize(s)); diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs index 178bf2be7fe..05890035273 100644 --- a/src/libstd/sha1.rs +++ b/src/libstd/sha1.rs @@ -13,7 +13,6 @@ */ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /* * A SHA-1 implementation derived from Paul E. Jones's reference diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 5fc8ead59fd..e3927ef188c 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -3,7 +3,6 @@ * are O(highest integer key). */ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::option; use core::option::{Some, None}; @@ -56,7 +55,7 @@ pure fn get(self: SmallIntMap, key: uint) -> T { error!("smallintmap::get(): key not present"); fail; } - Some(v) => return v + Some(move v) => return v } } @@ -117,7 +116,7 @@ impl SmallIntMap: map::Map { let mut idx = 0u, l = self.v.len(); while idx < l { match self.v.get_elt(idx) { - Some(elt) => if !it(&idx, &elt) { break }, + Some(ref elt) => if !it(&idx, elt) { break }, None => () } idx += 1u; diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index 20a18b88320..f783addcf50 100644 --- a/src/libstd/sort.rs +++ b/src/libstd/sort.rs @@ -1,6 +1,5 @@ //! Sorting methods #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use vec::{len, push}; use core::cmp::{Eq, Ord}; diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 96d7b8c20fc..5370f20cfa1 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -23,6 +23,7 @@ not required in or otherwise suitable for the core library. #[allow(vecs_implicitly_copyable)]; #[deny(non_camel_case_types)]; +#[forbid(deprecated_pattern)]; extern mod core(vers = "0.4"); use core::*; diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index 7638b43ad86..c94a1ab46bf 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -1,6 +1,5 @@ // NB: transitionary, de-mode-ing. #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; /** * The concurrency primitives you know and love. * diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs index 5c59bc02cb7..84c04aa1bd7 100644 --- a/src/libstd/tempfile.rs +++ b/src/libstd/tempfile.rs @@ -1,7 +1,6 @@ //! Temporary files and directories #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::option; use option::{None, Some}; diff --git a/src/libstd/term.rs b/src/libstd/term.rs index af7fde5a174..2c12fd11e6e 100644 --- a/src/libstd/term.rs +++ b/src/libstd/term.rs @@ -1,6 +1,5 @@ //! Simple ANSI color library #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::Option; @@ -38,9 +37,9 @@ pub fn color_supported() -> bool { let supported_terms = ~[~"xterm-color", ~"xterm", ~"screen-bce", ~"xterm-256color"]; return match os::getenv(~"TERM") { - option::Some(env) => { + option::Some(ref env) => { for vec::each(supported_terms) |term| { - if *term == env { return true; } + if *term == *env { return true; } } false } diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 50366768e96..cb69c60a1c2 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -6,7 +6,6 @@ // while providing a base that other test frameworks may build off of. #[warn(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::cmp::Eq; use either::Either; @@ -59,8 +58,8 @@ type TestDesc = { fn test_main(args: &[~str], tests: &[TestDesc]) { let opts = match parse_opts(args) { - either::Left(o) => o, - either::Right(m) => fail m + either::Left(move o) => o, + either::Right(move m) => fail m }; if !run_tests_console(&opts, tests) { fail ~"Some tests failed"; } } @@ -76,8 +75,8 @@ fn parse_opts(args: &[~str]) -> OptRes { let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")]; let matches = match getopts::getopts(args_, opts) { - Ok(m) => m, - Err(f) => return either::Right(getopts::fail_str(f)) + Ok(move m) => m, + Err(move f) => return either::Right(getopts::fail_str(f)) }; let filter = @@ -120,13 +119,13 @@ fn run_tests_console(opts: &TestOpts, fn callback(event: &TestEvent, st: ConsoleTestState) { debug!("callback(event=%?)", event); match *event { - TeFiltered(filtered_tests) => { - st.total = vec::len(filtered_tests); + TeFiltered(ref filtered_tests) => { + st.total = filtered_tests.len(); let noun = if st.total != 1u { ~"tests" } else { ~"test" }; st.out.write_line(fmt!("\nrunning %u %s", st.total, noun)); } - TeWait(test) => st.out.write_str(fmt!("test %s ... ", test.name)), - TeResult(test, result) => { + TeWait(ref test) => st.out.write_str(fmt!("test %s ... ", test.name)), + TeResult(copy test, result) => { match st.log_out { Some(f) => write_log(f, result, &test), None => () @@ -141,7 +140,7 @@ fn run_tests_console(opts: &TestOpts, st.failed += 1u; write_failed(st.out, st.use_color); st.out.write_line(~""); - st.failures.push(copy test); + st.failures.push(test); } TrIgnored => { st.ignored += 1u; @@ -154,11 +153,11 @@ fn run_tests_console(opts: &TestOpts, } let log_out = match opts.logfile { - Some(path) => match io::file_writer(&Path(path), + Some(ref path) => match io::file_writer(&Path(*path), ~[io::Create, io::Truncate]) { result::Ok(w) => Some(w), - result::Err(s) => { - fail(fmt!("can't open output file: %s", s)) + result::Err(ref s) => { + fail(fmt!("can't open output file: %s", *s)) } }, None => None @@ -347,7 +346,7 @@ fn filter_tests(opts: &TestOpts, } else { let filter_str = match opts.filter { - option::Some(f) => f, + option::Some(copy f) => f, option::None => ~"" }; diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 890a7a0b468..2975d27e064 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::cmp::Eq; use libc::{c_char, c_int, c_long, size_t, time_t}; @@ -576,7 +575,7 @@ fn strptime(s: &str, format: &str) -> Result { match rdr.read_char() { '%' => match parse_type(s, pos, rdr.read_char(), &tm) { Ok(next) => pos = next, - Err(e) => { result = Err(e); break; } + Err(copy e) => { result = Err(e); break; } }, c => { if c != ch { break } diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index 1476d6bdf31..ae79892b873 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -1,7 +1,6 @@ //! Utilities that leverage libuv's `uv_timer_*` API #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use uv = uv; use uv::iotask; diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 3419f1cb90c..184dfd36279 100644 --- a/src/libstd/treemap.rs +++ b/src/libstd/treemap.rs @@ -6,7 +6,6 @@ * red-black tree or something else. */ #[warn(deprecated_mode)]; -#[forbid(deprecated_pattern)]; use core::cmp::{Eq, Ord}; use core::option::{Some, None}; diff --git a/src/libstd/unicode.rs b/src/libstd/unicode.rs index e76b8529730..d353be2b44b 100644 --- a/src/libstd/unicode.rs +++ b/src/libstd/unicode.rs @@ -1,5 +1,4 @@ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; mod icu { #[legacy_exports]; diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs index cde88db031e..508426588d0 100644 --- a/src/libstd/uv_global_loop.rs +++ b/src/libstd/uv_global_loop.rs @@ -1,7 +1,6 @@ //! A process-wide libuv event loop for library use. #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; export get; diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index 2e008830558..c31238ecf4f 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -6,7 +6,6 @@ */ #[forbid(deprecated_mode)]; -#[forbid(deprecated_pattern)]; export IoTask; export spawn_iotask; @@ -149,7 +148,7 @@ extern fn wake_up_cb(async_handle: *ll::uv_async_t, while msg_po.peek() { match msg_po.recv() { - Interaction(cb) => cb(loop_ptr), + Interaction(ref cb) => (*cb)(loop_ptr), TeardownLoop => begin_teardown(data) } } -- cgit 1.4.1-3-g733a5 From 21519bc7e0a32e388e8b12be5d36d4440129f417 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Thu, 27 Sep 2012 22:20:47 -0700 Subject: demode vec --- src/cargo/cargo.rs | 2 +- src/compiletest/runtest.rs | 5 +- src/fuzzer/fuzzer.rs | 2 +- src/libcore/dlist.rs | 2 +- src/libcore/dvec.rs | 8 +- src/libcore/float.rs | 2 +- src/libcore/io.rs | 6 +- src/libcore/os.rs | 6 +- src/libcore/path.rs | 6 +- src/libcore/pipes.rs | 4 +- src/libcore/ptr.rs | 6 +- src/libcore/str.rs | 8 +- src/libcore/tuple.rs | 43 +- src/libcore/vec.rs | 530 ++++++++++++--------- src/libstd/ebml.rs | 2 +- src/libstd/ebml2.rs | 2 +- src/libstd/getopts.rs | 5 +- src/libstd/json.rs | 2 +- src/libstd/list.rs | 2 +- src/libstd/net_ip.rs | 2 +- src/libstd/net_tcp.rs | 2 +- src/libstd/par.rs | 8 +- src/libstd/smallintmap.rs | 2 +- src/libstd/test.rs | 4 +- src/libsyntax/ast_map.rs | 2 +- src/libsyntax/ast_util.rs | 4 +- src/libsyntax/attr.rs | 16 +- src/libsyntax/ext/auto_serialize.rs | 10 +- src/libsyntax/ext/auto_serialize2.rs | 12 +- src/libsyntax/ext/base.rs | 2 +- src/libsyntax/ext/expand.rs | 4 +- src/libsyntax/ext/pipes/pipec.rs | 4 +- src/libsyntax/ext/simplext.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 6 +- src/libsyntax/ext/tt/transcribe.rs | 11 +- src/libsyntax/fold.rs | 2 +- src/libsyntax/print/pprust.rs | 2 +- src/rustc/driver/rustc.rs | 2 +- src/rustc/front/config.rs | 23 +- src/rustc/front/test.rs | 8 +- src/rustc/metadata/cstore.rs | 4 +- src/rustc/metadata/decoder.rs | 2 +- src/rustc/middle/borrowck/check_loans.rs | 2 +- src/rustc/middle/borrowck/gather_loans.rs | 4 +- src/rustc/middle/check_alt.rs | 8 +- src/rustc/middle/const_eval.rs | 4 +- src/rustc/middle/kind.rs | 4 +- src/rustc/middle/liveness.rs | 8 +- src/rustc/middle/resolve.rs | 2 +- src/rustc/middle/trans/alt.rs | 2 +- src/rustc/middle/trans/base.rs | 2 +- src/rustc/middle/trans/common.rs | 2 +- src/rustc/middle/trans/controlflow.rs | 2 +- src/rustc/middle/trans/foreign.rs | 4 +- src/rustc/middle/trans/monomorphize.rs | 12 +- src/rustc/middle/trans/type_use.rs | 4 +- src/rustc/middle/ty.rs | 14 +- src/rustc/middle/typeck/check.rs | 10 +- src/rustc/middle/typeck/check/alt.rs | 2 +- src/rustc/middle/typeck/check/vtable.rs | 4 +- src/rustc/middle/typeck/collect.rs | 2 +- src/rustc/middle/typeck/infer.rs | 2 +- .../middle/typeck/infer/region_var_bindings.rs | 2 +- src/rustc/middle/typeck/infer/resolve.rs | 4 +- src/rustdoc/attr_pass.rs | 2 +- src/rustdoc/config.rs | 4 +- src/rustdoc/desc_to_brief_pass.rs | 6 +- src/rustdoc/doc.rs | 36 +- src/rustdoc/page_pass.rs | 2 +- src/rustdoc/path_pass.rs | 4 +- src/rustdoc/tystr_pass.rs | 2 +- src/rustdoc/unindent_pass.rs | 6 +- src/test/bench/core-std.rs | 2 +- src/test/bench/graph500-bfs.rs | 14 +- src/test/bench/msgsend-ring-mutex-arcs.rs | 2 +- src/test/bench/msgsend-ring-rw-arcs.rs | 2 +- .../compile-fail/block-arg-as-stmt-with-value.rs | 2 +- .../compile-fail/regions-escape-loop-via-vec.rs | 2 +- .../run-pass/block-arg-can-be-followed-by-binop.rs | 2 +- src/test/run-pass/block-arg-in-parentheses.rs | 8 +- src/test/run-pass/block-arg.rs | 22 +- src/test/run-pass/block-vec-map2.rs | 2 +- src/test/run-pass/ret-break-cont-in-block.rs | 8 +- 83 files changed, 541 insertions(+), 464 deletions(-) (limited to 'src/libstd/smallintmap.rs') diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs index dd0e53143f5..6136652c873 100644 --- a/src/cargo/cargo.rs +++ b/src/cargo/cargo.rs @@ -527,7 +527,7 @@ fn load_one_source_package(src: @Source, p: &json::Object) { Some(json::List(js)) => { for js.each |j| { match *j { - json::String(j) => vec::grow(tags, 1u, j), + json::String(ref j) => tags.grow(1u, j), _ => () } } diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index dae5105ce71..ff695f64088 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -503,10 +503,7 @@ fn make_run_args(config: config, _props: test_props, testfile: &Path) -> fn split_maybe_args(argstr: Option<~str>) -> ~[~str] { fn rm_whitespace(v: ~[~str]) -> ~[~str] { - fn flt(&&s: ~str) -> Option<~str> { - if !str::is_whitespace(s) { option::Some(s) } else { option::None } - } - vec::filter_map(v, flt) + vec::filter(v, |s| !str::is_whitespace(*s)) } match argstr { diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs index ab3c2c7c2ca..ace96c389ef 100644 --- a/src/fuzzer/fuzzer.rs +++ b/src/fuzzer/fuzzer.rs @@ -229,7 +229,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap, filename: &Path, cx: context) { let stolen = steal(crate, cx.mode); let extra_exprs = vec::filter(common_exprs(), - |a| safe_to_use_expr(a, cx.mode) ); + |a| safe_to_use_expr(*a, cx.mode) ); check_variants_T(crate, codemap, filename, ~"expr", extra_exprs + stolen.exprs, pprust::expr_to_str, replace_expr_in_crate, cx); diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs index fcf8146200d..0bdf5caec0c 100644 --- a/src/libcore/dlist.rs +++ b/src/libcore/dlist.rs @@ -99,7 +99,7 @@ pub pure fn from_elem(+data: T) -> DList { pub fn from_vec(+vec: &[T]) -> DList { do vec::foldl(DList(), vec) |list,data| { - list.push(data); // Iterating left-to-right -- add newly to the tail. + list.push(*data); // Iterating left-to-right -- add newly to the tail. list } } diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs index eb221926fc1..d360eab3c8a 100644 --- a/src/libcore/dvec.rs +++ b/src/libcore/dvec.rs @@ -157,7 +157,7 @@ impl DVec { fn pop() -> A { do self.check_out |v| { let mut v <- v; - let result = vec::pop(v); + let result = v.pop(); self.give_back(move v); move result } @@ -187,7 +187,7 @@ impl DVec { fn shift() -> A { do self.check_out |v| { let mut v = move v; - let result = vec::shift(v); + let result = v.shift(); self.give_back(move v); move result } @@ -305,10 +305,10 @@ impl DVec { * 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; - vec::grow_set(v, idx, initval, val); + v.grow_set(idx, initval, val); move v } } diff --git a/src/libcore/float.rs b/src/libcore/float.rs index aff6db3c10f..098e82f5fad 100644 --- a/src/libcore/float.rs +++ b/src/libcore/float.rs @@ -140,7 +140,7 @@ pub fn to_str_common(num: float, digits: uint, exact: bool) -> ~str { // turn digits into string // using stack of digits while fractionalParts.is_not_empty() { - let mut adjusted_digit = carry + vec::pop(fractionalParts); + let mut adjusted_digit = carry + fractionalParts.pop(); if adjusted_digit == 10 { carry = 1; diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 47ea01af677..667aaaf7b0e 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -64,11 +64,11 @@ trait ReaderUtil { impl T : ReaderUtil { fn read_bytes(len: uint) -> ~[u8] { let mut buf = vec::with_capacity(len); - unsafe { vec::raw::set_len(buf, len); } + unsafe { vec::raw::set_len(&mut buf, len); } let count = self.read(buf, len); - unsafe { vec::raw::set_len(buf, count); } + unsafe { vec::raw::set_len(&mut buf, count); } move buf } fn read_line() -> ~str { @@ -695,7 +695,7 @@ impl BytesWriter: Writer { let count = uint::max(buf_len, self.pos + v_len); vec::reserve(&mut buf, count); - unsafe { vec::raw::set_len(buf, count); } + unsafe { vec::raw::set_len(&mut buf, count); } { let view = vec::mut_view(buf, self.pos, count); diff --git a/src/libcore/os.rs b/src/libcore/os.rs index c1ea71c181b..644cef42b41 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -582,7 +582,7 @@ pub fn list_dir(p: &Path) -> ~[~str] { fn star(p: &Path) -> Path { p.push("*") } do rustrt::rust_list_files(star(p).to_str()).filter |filename| { - filename != ~"." && filename != ~".." + *filename != ~"." && *filename != ~".." } } @@ -857,10 +857,10 @@ mod tests { let mut e = env(); setenv(n, ~"VALUE"); - assert !vec::contains(e, (copy n, ~"VALUE")); + assert !vec::contains(e, &(copy n, ~"VALUE")); e = env(); - assert vec::contains(e, (n, ~"VALUE")); + assert vec::contains(e, &(n, ~"VALUE")); } #[test] diff --git a/src/libcore/path.rs b/src/libcore/path.rs index c384745bb5e..1afcc7ba09d 100644 --- a/src/libcore/path.rs +++ b/src/libcore/path.rs @@ -221,7 +221,7 @@ impl PosixPath : GenericPath { pure fn pop() -> PosixPath { let mut cs = copy self.components; if cs.len() != 0 { - unsafe { vec::pop(cs); } + unsafe { cs.pop(); } } return PosixPath { components: move cs, ..self } } @@ -415,7 +415,7 @@ impl WindowsPath : GenericPath { pure fn pop() -> WindowsPath { let mut cs = copy self.components; if cs.len() != 0 { - unsafe { vec::pop(cs); } + unsafe { cs.pop(); } } return WindowsPath { components: move cs, ..self } } @@ -437,7 +437,7 @@ pub pure fn normalize(components: &[~str]) -> ~[~str] { if *c == ~"." && components.len() > 1 { loop; } if *c == ~"" { loop; } if *c == ~".." && cs.len() != 0 { - vec::pop(cs); + cs.pop(); loop; } cs.push(copy *c); diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index 3559753410f..7a4d15ac4fe 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -704,7 +704,7 @@ pub fn select(+endpoints: ~[RecvPacketBuffered]) { let ready = wait_many(endpoints.map(|p| p.header())); let mut remaining <- endpoints; - let port = vec::swap_remove(remaining, ready); + let port = remaining.swap_remove(ready); let result = try_recv(move port); (ready, move result, move remaining) } @@ -1067,7 +1067,7 @@ impl PortSet : Recv { } None => { // Remove this port. - let _ = vec::swap_remove(ports, i); + let _ = ports.swap_remove(i); } } } diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 72fa2cda1a7..7f1f1e4b345 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -127,7 +127,7 @@ pub unsafe fn memset(dst: *mut T, c: int, count: uint) { reinterpret_cast. */ #[inline(always)] -pub fn to_unsafe_ptr(thing: &T) -> *T { +pub pure fn to_unsafe_ptr(thing: &T) -> *T { unsafe { cast::reinterpret_cast(&thing) } } @@ -137,7 +137,7 @@ pub fn to_unsafe_ptr(thing: &T) -> *T { reinterpret_cast. */ #[inline(always)] -pub fn to_const_unsafe_ptr(thing: &const T) -> *const T { +pub pure fn to_const_unsafe_ptr(thing: &const T) -> *const T { unsafe { cast::reinterpret_cast(&thing) } } @@ -147,7 +147,7 @@ pub fn to_const_unsafe_ptr(thing: &const T) -> *const T { reinterpret_cast. */ #[inline(always)] -pub fn to_mut_unsafe_ptr(thing: &mut T) -> *mut T { +pub pure fn to_mut_unsafe_ptr(thing: &mut T) -> *mut T { unsafe { cast::reinterpret_cast(&thing) } } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index d7e90c1a42d..a932a6133c5 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -450,7 +450,7 @@ Section: Transforming strings */ pure fn to_bytes(s: &str) -> ~[u8] unsafe { let mut v: ~[u8] = ::cast::transmute(from_slice(s)); - vec::raw::set_len(v, len(s)); + vec::raw::set_len(&mut v, len(s)); move v } @@ -1945,7 +1945,7 @@ fn reserve_at_least(s: &const ~str, n: uint) { */ pure fn capacity(s: &const ~str) -> uint { do as_bytes(s) |buf| { - let vcap = vec::capacity(*buf); + let vcap = vec::capacity(buf); assert vcap > 0u; vcap - 1u } @@ -2008,7 +2008,7 @@ mod raw { vec::as_mut_buf(v, |vbuf, _len| { ptr::memcpy(vbuf, buf as *u8, len) }); - vec::raw::set_len(v, len); + vec::raw::set_len(&mut v, len); v.push(0u8); assert is_utf8(v); @@ -2065,7 +2065,7 @@ mod raw { let src = ptr::offset(sbuf, begin); ptr::memcpy(vbuf, src, end - begin); } - vec::raw::set_len(v, end - begin); + vec::raw::set_len(&mut v, end - begin); v.push(0u8); ::cast::transmute(move v) } diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index a89661c3291..50f55383167 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -35,35 +35,44 @@ impl (T, U): TupleOps { } trait ExtendedTupleOps { - fn zip() -> ~[(A, B)]; - fn map(f: &fn(A, B) -> C) -> ~[C]; + fn zip(&self) -> ~[(A, B)]; + fn map(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C]; } impl (&[A], &[B]): ExtendedTupleOps { - - fn zip() -> ~[(A, B)] { - let (a, b) = self; - vec::zip_slice(a, b) + fn zip(&self) -> ~[(A, B)] { + match *self { + (ref a, ref b) => { + vec::zip_slice(*a, *b) + } + } } - fn map(f: &fn(A, B) -> C) -> ~[C] { - let (a, b) = self; - vec::map2(a, b, f) + fn map(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] { + match *self { + (ref a, ref b) => { + vec::map2(*a, *b, f) + } + } } } impl (~[A], ~[B]): ExtendedTupleOps { - fn zip() -> ~[(A, B)] { - // FIXME #2543: Bad copy - let (a, b) = copy self; - vec::zip(move a, move b) + fn zip(&self) -> ~[(A, B)] { + match *self { + (ref a, ref b) => { + vec::zip_slice(*a, *b) + } + } } - fn map(f: &fn(A, B) -> C) -> ~[C] { - // FIXME #2543: Bad copy - let (a, b) = copy self; - vec::map2(a, b, f) + fn map(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C] { + match *self { + (ref a, ref b) => { + vec::map2(*a, *b, f) + } + } } } diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index 07ccb244ddd..914434c9d46 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -1,5 +1,9 @@ //! Vectors +#[warn(deprecated_mode)]; +#[warn(deprecated_pattern)]; +#[warn(non_camel_case_types)]; + use cmp::{Eq, Ord}; use option::{Some, None}; use ptr::addr_of; @@ -140,7 +144,7 @@ pure fn same_length(xs: &[const T], ys: &[const U]) -> bool { */ fn reserve(+v: &mut ~[T], +n: uint) { // Only make the (slow) call into the runtime if we have to - if capacity(*v) < n { + if capacity(v) < n { unsafe { let ptr: **raw::VecRepr = cast::transmute(v); rustrt::vec_reserve_shared(sys::get_type_desc::(), @@ -170,16 +174,16 @@ fn reserve_at_least(v: &mut ~[T], n: uint) { /// Returns the number of elements the vector can hold without reallocating #[inline(always)] -pure fn capacity(&&v: ~[const T]) -> uint { +pure fn capacity(v: &const ~[T]) -> uint { unsafe { - let repr: **raw::VecRepr = ::cast::reinterpret_cast(&addr_of(v)); + let repr: **raw::VecRepr = ::cast::transmute(v); (**repr).unboxed.alloc / sys::size_of::() } } /// Returns the length of a vector #[inline(always)] -pure fn len(&&v: &[const T]) -> uint { +pure fn len(v: &[const T]) -> uint { as_const_buf(v, |_p, len| len) } @@ -190,11 +194,18 @@ pure fn len(&&v: &[const T]) -> uint { * to the value returned by the function `op`. */ pure fn from_fn(n_elts: uint, op: iter::InitOp) -> ~[T] { - let mut v = with_capacity(n_elts); - let mut i: uint = 0u; - while i < n_elts unsafe { raw::set(v, i, op(i)); i += 1u; } - unsafe { raw::set_len(v, n_elts); } - move v + unsafe { + let mut v = with_capacity(n_elts); + do as_mut_buf(v) |p, _len| { + let mut i: uint = 0u; + while i < n_elts { + rusti::move_val_init(*ptr::mut_offset(p, i), op(i)); + i += 1u; + } + } + raw::set_len(&mut v, n_elts); + return move v; + } } /** @@ -203,14 +214,8 @@ pure fn from_fn(n_elts: uint, op: iter::InitOp) -> ~[T] { * Creates an immutable vector of size `n_elts` and initializes the elements * to the value `t`. */ -pure fn from_elem(n_elts: uint, t: T) -> ~[T] { - let mut v = with_capacity(n_elts); - let mut i: uint = 0u; - unsafe { // because unsafe::set is unsafe - while i < n_elts { raw::set(v, i, t); i += 1u; } - unsafe { raw::set_len(v, n_elts); } - } - move v +pure fn from_elem(n_elts: uint, +t: T) -> ~[T] { + from_fn(n_elts, |_i| copy t) } /// Creates a new unique vector with the same contents as the slice @@ -378,7 +383,7 @@ pure fn const_view(v: &r/[const T], start: uint, } /// Split the vector `v` by applying each element against the predicate `f`. -fn split(v: &[T], f: fn(T) -> bool) -> ~[~[T]] { +fn split(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] { let ln = len(v); if (ln == 0u) { return ~[] } @@ -401,7 +406,7 @@ fn split(v: &[T], f: fn(T) -> bool) -> ~[~[T]] { * Split the vector `v` by applying each element against the predicate `f` up * to `n` times. */ -fn splitn(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] { +fn splitn(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] { let ln = len(v); if (ln == 0u) { return ~[] } @@ -427,7 +432,7 @@ fn splitn(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] { * Reverse split the vector `v` by applying each element against the predicate * `f`. */ -fn rsplit(v: &[T], f: fn(T) -> bool) -> ~[~[T]] { +fn rsplit(v: &[T], f: fn(t: &T) -> bool) -> ~[~[T]] { let ln = len(v); if (ln == 0u) { return ~[] } @@ -451,7 +456,7 @@ fn rsplit(v: &[T], f: fn(T) -> bool) -> ~[~[T]] { * Reverse split the vector `v` by applying each element against the predicate * `f` up to `n times. */ -fn rsplitn(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] { +fn rsplitn(v: &[T], n: uint, f: fn(t: &T) -> bool) -> ~[~[T]] { let ln = len(v); if (ln == 0u) { return ~[] } @@ -477,12 +482,12 @@ fn rsplitn(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] { // Mutators /// Removes the first element from a vector and return it -fn shift(&v: ~[T]) -> T { - let ln = len::(v); +fn shift(v: &mut ~[T]) -> T { + let ln = v.len(); assert (ln > 0); let mut vv = ~[]; - v <-> vv; + *v <-> vv; unsafe { let mut rr; @@ -495,22 +500,22 @@ fn shift(&v: ~[T]) -> T { v.push(move r); } } - raw::set_len(vv, 0); + raw::set_len(&mut vv, 0); move rr } } /// Prepend an element to the vector -fn unshift(&v: ~[T], +x: T) { +fn unshift(v: &mut ~[T], +x: T) { let mut vv = ~[move x]; - v <-> vv; - while len(vv) > 0 { - v.push(shift(vv)); - } + *v <-> vv; + v.push_all_move(vv); } fn consume(+v: ~[T], f: fn(uint, +v: T)) unsafe { + let mut v = move v; // FIXME(#3488) + do as_imm_buf(v) |p, ln| { for uint::range(0, ln) |i| { let x <- *ptr::offset(p, i); @@ -518,29 +523,22 @@ fn consume(+v: ~[T], f: fn(uint, +v: T)) unsafe { } } - raw::set_len(v, 0); + raw::set_len(&mut v, 0); } -fn consume_mut(+v: ~[mut T], f: fn(uint, +v: T)) unsafe { - do as_imm_buf(v) |p, ln| { - for uint::range(0, ln) |i| { - let x <- *ptr::offset(p, i); - f(i, move x); - } - } - - raw::set_len(v, 0); +fn consume_mut(+v: ~[mut T], f: fn(uint, +v: T)) { + consume(vec::from_mut(v), f) } /// Remove the last element from a vector and return it -fn pop(&v: ~[const T]) -> T { - let ln = len(v); +fn pop(v: &mut ~[T]) -> T { + let ln = v.len(); if ln == 0 { fail ~"sorry, cannot vec::pop an empty vector" } - let valptr = ptr::mut_addr_of(v[ln - 1u]); + let valptr = ptr::to_mut_unsafe_ptr(&mut v[ln - 1u]); unsafe { - let val <- *valptr; + let val = move *valptr; raw::set_len(v, ln - 1u); move val } @@ -552,21 +550,15 @@ fn pop(&v: ~[const T]) -> T { * * Fails if index >= length. */ -fn swap_remove(&v: ~[const T], index: uint) -> T { - let ln = len(v); +fn swap_remove(v: &mut ~[T], index: uint) -> T { + let ln = v.len(); if index >= ln { fail fmt!("vec::swap_remove - index %u >= length %u", index, ln); } - let lastptr = ptr::mut_addr_of(v[ln - 1]); - unsafe { - let mut val <- *lastptr; - if index < ln - 1 { - let valptr = ptr::mut_addr_of(v[index]); - *valptr <-> val; - } - raw::set_len(v, ln - 1); - move val + if index < ln - 1 { + v[index] <-> v[ln - 1]; } + vec::pop(v) } /// Append an element to a vector @@ -611,7 +603,8 @@ fn push_all(+v: &mut ~[T], rhs: &[const T]) { } #[inline(always)] -fn push_all_move(v: &mut ~[T], -rhs: ~[const T]) { +fn push_all_move(v: &mut ~[T], +rhs: ~[T]) { + let mut rhs = move rhs; // FIXME(#3488) reserve(v, v.len() + rhs.len()); unsafe { do as_imm_buf(rhs) |p, len| { @@ -620,13 +613,13 @@ fn push_all_move(v: &mut ~[T], -rhs: ~[const T]) { push(v, move x); } } - raw::set_len(rhs, 0); + raw::set_len(&mut rhs, 0); } } /// Shorten a vector, dropping excess elements. -fn truncate(&v: ~[const T], newlen: uint) { - do as_imm_buf(v) |p, oldlen| { +fn truncate(v: &mut ~[T], newlen: uint) { + do as_imm_buf(*v) |p, oldlen| { assert(newlen <= oldlen); unsafe { // This loop is optimized out for non-drop types. @@ -642,10 +635,10 @@ fn truncate(&v: ~[const T], newlen: uint) { * Remove consecutive repeated elements from a vector; if the vector is * sorted, this removes all duplicates. */ -fn dedup(&v: ~[const T]) unsafe { +fn dedup(v: &mut ~[T]) unsafe { if v.len() < 1 { return; } let mut last_written = 0, next_to_read = 1; - do as_const_buf(v) |p, ln| { + do as_const_buf(*v) |p, ln| { // We have a mutable reference to v, so we can make arbitrary changes. // (cf. push and pop) let p = p as *mut T; @@ -704,12 +697,12 @@ pure fn append_mut(+lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] { * * n - The number of elements to add * * initval - The value for the new elements */ -fn grow(&v: ~[T], n: uint, initval: T) { - reserve_at_least(&mut v, len(v) + n); +fn grow(v: &mut ~[T], n: uint, initval: &T) { + reserve_at_least(v, v.len() + n); let mut i: uint = 0u; while i < n { - v.push(initval); + v.push(*initval); i += 1u; } } @@ -727,8 +720,8 @@ fn grow(&v: ~[T], n: uint, initval: T) { * * init_op - A function to call to retreive each appended element's * value */ -fn grow_fn(&v: ~[T], n: uint, op: iter::InitOp) { - reserve_at_least(&mut v, len(v) + n); +fn grow_fn(v: &mut ~[T], n: uint, op: iter::InitOp) { + reserve_at_least(v, v.len() + n); let mut i: uint = 0u; while i < n { v.push(op(i)); @@ -744,15 +737,16 @@ fn grow_fn(&v: ~[T], n: uint, op: iter::InitOp) { * of the vector, expands the vector by replicating `initval` to fill the * intervening space. */ -fn grow_set(&v: ~[T], index: uint, initval: T, val: T) { - if index >= len(v) { grow(v, index - len(v) + 1u, initval); } - v[index] = val; +fn grow_set(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; } // Functional utilities /// Apply a function to each element of a vector and return the results -pure fn map(v: &[T], f: fn(v: &T) -> U) -> ~[U] { +pure fn map(v: &[T], f: fn(t: &T) -> U) -> ~[U] { let mut result = with_capacity(len(v)); for each(v) |elem| { unsafe { @@ -771,7 +765,7 @@ fn map_consume(+v: ~[T], f: fn(+v: T) -> U) -> ~[U] { } /// Apply a function to each element of a vector and return the results -pure fn mapi(v: &[T], f: fn(uint, v: &T) -> U) -> ~[U] { +pure fn mapi(v: &[T], f: fn(uint, t: &T) -> U) -> ~[U] { let mut i = 0; do map(v) |e| { i += 1; @@ -783,21 +777,21 @@ pure fn mapi(v: &[T], f: fn(uint, v: &T) -> U) -> ~[U] { * Apply a function to each element of a vector and return a concatenation * of each result vector */ -pure fn flat_map(v: &[T], f: fn(T) -> ~[U]) -> ~[U] { +pure fn flat_map(v: &[T], f: fn(t: &T) -> ~[U]) -> ~[U] { let mut result = ~[]; - for each(v) |elem| { unsafe{ result.push_all_move(f(*elem)); } } + for each(v) |elem| { unsafe{ result.push_all_move(f(elem)); } } move result } /// Apply a function to each pair of elements and return the results pure fn map2(v0: &[T], v1: &[U], - f: fn(T, U) -> V) -> ~[V] { + f: fn(t: &T, v: &U) -> V) -> ~[V] { let v0_len = len(v0); if v0_len != len(v1) { fail; } let mut u: ~[V] = ~[]; let mut i = 0u; while i < v0_len { - unsafe { u.push(f(copy v0[i], copy v1[i])) }; + unsafe { u.push(f(&v0[i], &v1[i])) }; i += 1u; } move u @@ -809,11 +803,11 @@ pure fn map2(v0: &[T], v1: &[U], * If function `f` returns `none` then that element is excluded from * the resulting vector. */ -pure fn filter_map(v: &[T], f: fn(T) -> Option) +pure fn filter_map(v: &[T], f: fn(t: &T) -> Option) -> ~[U] { let mut result = ~[]; for each(v) |elem| { - match f(*elem) { + match f(elem) { None => {/* no-op */ } Some(result_elem) => unsafe { result.push(result_elem); } } @@ -828,10 +822,10 @@ pure fn filter_map(v: &[T], f: fn(T) -> Option) * Apply function `f` to each element of `v` and return a vector containing * only those elements for which `f` returned true. */ -pure fn filter(v: &[T], f: fn(T) -> bool) -> ~[T] { +pure fn filter(v: &[T], f: fn(t: &T) -> bool) -> ~[T] { let mut result = ~[]; for each(v) |elem| { - if f(*elem) { unsafe { result.push(*elem); } } + if f(elem) { unsafe { result.push(*elem); } } } move result } @@ -848,30 +842,32 @@ pure fn concat(v: &[~[T]]) -> ~[T] { } /// Concatenate a vector of vectors, placing a given separator between each -pure fn connect(v: &[~[T]], sep: T) -> ~[T] { +pure fn connect(v: &[~[T]], sep: &T) -> ~[T] { let mut r: ~[T] = ~[]; let mut first = true; for each(v) |inner| { - if first { first = false; } else { unsafe { r.push(sep); } } + if first { first = false; } else { unsafe { r.push(*sep); } } unsafe { r.push_all(*inner) }; } move r } /// Reduce a vector from left to right -pure fn foldl(z: T, v: &[U], p: fn(T, U) -> T) -> T { +pure fn foldl(+z: T, v: &[U], p: fn(+t: T, u: &U) -> T) -> T { let mut accum = z; for each(v) |elt| { - accum = p(accum, *elt); + // it should be possible to move accum in, but the liveness analysis + // is not smart enough. + accum = p(accum, elt); } return accum; } /// Reduce a vector from right to left -pure fn foldr(v: &[T], z: U, p: fn(T, U) -> U) -> U { +pure fn foldr(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); + accum = p(elt, accum); } return accum; } @@ -881,8 +877,8 @@ pure fn foldr(v: &[T], z: U, p: fn(T, U) -> U) -> U { * * If the vector contains no elements then false is returned. */ -pure fn any(v: &[T], f: fn(T) -> bool) -> bool { - for each(v) |elem| { if f(*elem) { return true; } } +pure fn any(v: &[T], f: fn(t: &T) -> bool) -> bool { + for each(v) |elem| { if f(elem) { return true; } } return false; } @@ -892,12 +888,12 @@ pure fn any(v: &[T], f: fn(T) -> bool) -> bool { * If the vectors contains no elements then false is returned. */ pure fn any2(v0: &[T], v1: &[U], - f: fn(T, U) -> bool) -> bool { + f: fn(a: &T, b: &U) -> bool) -> bool { let v0_len = len(v0); let v1_len = len(v1); let mut i = 0u; while i < v0_len && i < v1_len { - if f(v0[i], v1[i]) { return true; }; + if f(&v0[i], &v1[i]) { return true; }; i += 1u; } return false; @@ -908,8 +904,8 @@ pure fn any2(v0: &[T], v1: &[U], * * If the vector contains no elements then true is returned. */ -pure fn all(v: &[T], f: fn(T) -> bool) -> bool { - for each(v) |elem| { if !f(*elem) { return false; } } +pure fn all(v: &[T], f: fn(t: &T) -> bool) -> bool { + for each(v) |elem| { if !f(elem) { return false; } } return true; } @@ -918,8 +914,8 @@ pure fn all(v: &[T], f: fn(T) -> bool) -> bool { * * If the vector contains no elements then true is returned. */ -pure fn alli(v: &[T], f: fn(uint, T) -> bool) -> bool { - for eachi(v) |i, elem| { if !f(i, *elem) { return false; } } +pure fn alli(v: &[T], f: fn(uint, t: &T) -> bool) -> bool { + for eachi(v) |i, elem| { if !f(i, elem) { return false; } } return true; } @@ -929,24 +925,24 @@ pure fn alli(v: &[T], f: fn(uint, T) -> bool) -> bool { * If the vectors are not the same size then false is returned. */ pure fn all2(v0: &[T], v1: &[U], - f: fn(T, U) -> bool) -> bool { + f: fn(t: &T, u: &U) -> bool) -> bool { let v0_len = len(v0); if v0_len != len(v1) { return false; } let mut i = 0u; - while i < v0_len { if !f(v0[i], v1[i]) { return false; }; i += 1u; } + while i < v0_len { if !f(&v0[i], &v1[i]) { return false; }; i += 1u; } return true; } /// Return true if a vector contains an element with the given value -pure fn contains(v: &[T], x: T) -> bool { - for each(v) |elt| { if x == *elt { return true; } } +pure fn contains(v: &[T], x: &T) -> bool { + for each(v) |elt| { if *x == *elt { return true; } } return false; } /// Returns the number of elements that are equal to a given value -pure fn count(v: &[T], x: T) -> uint { +pure fn count(v: &[T], x: &T) -> uint { let mut cnt = 0u; - for each(v) |elt| { if x == *elt { cnt += 1u; } } + for each(v) |elt| { if *x == *elt { cnt += 1u; } } return cnt; } @@ -957,7 +953,7 @@ pure fn count(v: &[T], x: T) -> uint { * When function `f` returns true then an option containing the element * is returned. If `f` matches no elements then none is returned. */ -pure fn find(v: &[T], f: fn(T) -> bool) -> Option { +pure fn find(v: &[T], f: fn(t: &T) -> bool) -> Option { find_between(v, 0u, len(v), f) } @@ -969,7 +965,7 @@ pure fn find(v: &[T], f: fn(T) -> bool) -> Option { * the element is returned. If `f` matches no elements then none is returned. */ pure fn find_between(v: &[T], start: uint, end: uint, - f: fn(T) -> bool) -> Option { + f: fn(t: &T) -> bool) -> Option { position_between(v, start, end, f).map(|i| v[*i]) } @@ -980,7 +976,7 @@ pure fn find_between(v: &[T], start: uint, end: uint, * `f` returns true then an option containing the element is returned. If `f` * matches no elements then none is returned. */ -pure fn rfind(v: &[T], f: fn(T) -> bool) -> Option { +pure fn rfind(v: &[T], f: fn(t: &T) -> bool) -> Option { rfind_between(v, 0u, len(v), f) } @@ -989,16 +985,16 @@ pure fn rfind(v: &[T], f: fn(T) -> bool) -> Option { * * Apply function `f` to each element of `v` in reverse order within the range * [`start`, `end`). When function `f` returns true then an option containing - * the element is returned. If `f` matches no elements then none is returned. + * the element is returned. If `f` matches no elements then none is return. */ pure fn rfind_between(v: &[T], start: uint, end: uint, - f: fn(T) -> bool) -> Option { + f: fn(t: &T) -> bool) -> Option { rposition_between(v, start, end, f).map(|i| v[*i]) } /// Find the first index containing a matching value -pure fn position_elem(v: &[T], x: T) -> Option { - position(v, |y| x == y) +pure fn position_elem(v: &[T], x: &T) -> Option { + position(v, |y| *x == *y) } /** @@ -1008,7 +1004,7 @@ pure fn position_elem(v: &[T], x: T) -> Option { * then an option containing the index is returned. If `f` matches no elements * then none is returned. */ -pure fn position(v: &[T], f: fn(T) -> bool) -> Option { +pure fn position(v: &[T], f: fn(t: &T) -> bool) -> Option { position_between(v, 0u, len(v), f) } @@ -1020,17 +1016,17 @@ pure fn position(v: &[T], f: fn(T) -> bool) -> Option { * the index is returned. If `f` matches no elements then none is returned. */ pure fn position_between(v: &[T], start: uint, end: uint, - f: fn(T) -> bool) -> Option { + f: fn(t: &T) -> bool) -> Option { assert start <= end; assert end <= len(v); let mut i = start; - while i < end { if f(v[i]) { return Some::(i); } i += 1u; } + while i < end { if f(&v[i]) { return Some::(i); } i += 1u; } return None; } /// Find the last index containing a matching value -pure fn rposition_elem(v: &[T], x: T) -> Option { - rposition(v, |y| x == y) +pure fn rposition_elem(v: &[T], x: &T) -> Option { + rposition(v, |y| *x == *y) } /** @@ -1040,7 +1036,7 @@ pure fn rposition_elem(v: &[T], x: T) -> Option { * `f` returns true then an option containing the index is returned. If `f` * matches no elements then none is returned. */ -pure fn rposition(v: &[T], f: fn(T) -> bool) -> Option { +pure fn rposition(v: &[T], f: fn(t: &T) -> bool) -> Option { rposition_between(v, 0u, len(v), f) } @@ -1053,12 +1049,12 @@ pure fn rposition(v: &[T], f: fn(T) -> bool) -> Option { * returned. */ pure fn rposition_between(v: &[T], start: uint, end: uint, - f: fn(T) -> bool) -> Option { + f: fn(t: &T) -> bool) -> Option { assert start <= end; assert end <= len(v); let mut i = end; while i > start { - if f(v[i - 1u]) { return Some::(i - 1u); } + if f(&v[i - 1u]) { return Some::(i - 1u); } i -= 1u; } return None; @@ -1122,12 +1118,13 @@ pure fn zip_slice(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. */ -pure fn zip(+v: ~[const T], +u: ~[const U]) -> ~[(T, U)] { - let mut v = move v, u = move u, i = len(v); +pure fn zip(+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); let mut w = with_capacity(i); while i > 0 { - unsafe { w.push((pop(v),pop(u))); } + unsafe { w.push((v.pop(),u.pop())); } i -= 1; } unsafe { reverse(w); } @@ -1269,10 +1266,10 @@ pure fn rev_eachi(v: &r/[T], blk: fn(i: uint, v: &r/T) -> bool) { * Both vectors must have the same length */ #[inline] -fn iter2(v1: &[U], v2: &[T], f: fn(U, T)) { +fn iter2(v1: &[U], v2: &[T], f: fn(u: &U, t: &T)) { assert len(v1) == len(v2); for uint::range(0u, len(v1)) |i| { - f(v1[i], v2[i]) + f(&v1[i], &v2[i]) } } @@ -1286,20 +1283,24 @@ fn iter2(v1: &[U], v2: &[T], f: fn(U, T)) { * The total number of permutations produced is `len(v)!`. If `v` contains * repeated elements, then some permutations are repeated. */ -pure fn permute(v: &[const T], put: fn(~[T])) { +pure fn each_permutation(+v: &[T], put: fn(ts: &[T]) -> bool) { let ln = len(v); - if ln == 0u { - put(~[]); + if ln <= 1 { + put(v); } else { + // This does not seem like the most efficient implementation. You + // could make far fewer copies if you put your mind to it. let mut i = 0u; while i < ln { let elt = v[i]; let mut rest = slice(v, 0u, i); unsafe { rest.push_all(const_view(v, i+1u, ln)); - permute(rest, |permutation| { - put(append(~[elt], permutation)) - }) + for each_permutation(rest) |permutation| { + if !put(append(~[elt], permutation)) { + return; + } + } } i += 1u; } @@ -1528,20 +1529,20 @@ impl &[const T]: CopyableVector { trait ImmutableVector { pure fn view(start: uint, end: uint) -> &self/[T]; - pure fn foldr(z: U, p: fn(T, U) -> U) -> U; - pure fn map(f: fn(v: &T) -> U) -> ~[U]; - pure fn mapi(f: fn(uint, v: &T) -> U) -> ~[U]; + pure fn foldr(z: U, p: fn(t: &T, +u: U) -> U) -> U; + pure fn map(f: fn(t: &T) -> U) -> ~[U]; + pure fn mapi(f: fn(uint, t: &T) -> U) -> ~[U]; fn map_r(f: fn(x: &T) -> U) -> ~[U]; - pure fn alli(f: fn(uint, T) -> bool) -> bool; - pure fn flat_map(f: fn(T) -> ~[U]) -> ~[U]; - pure fn filter_map(f: fn(T) -> Option) -> ~[U]; + pure fn alli(f: fn(uint, t: &T) -> bool) -> bool; + pure fn flat_map(f: fn(t: &T) -> ~[U]) -> ~[U]; + pure fn filter_map(f: fn(t: &T) -> Option) -> ~[U]; } trait ImmutableEqVector { - pure fn position(f: fn(T) -> bool) -> Option; - pure fn position_elem(x: T) -> Option; - pure fn rposition(f: fn(T) -> bool) -> Option; - pure fn rposition_elem(x: T) -> Option; + pure fn position(f: fn(t: &T) -> bool) -> Option; + pure fn position_elem(t: &T) -> Option; + pure fn rposition(f: fn(t: &T) -> bool) -> Option; + pure fn rposition_elem(t: &T) -> Option; } /// Extension methods for vectors @@ -1552,15 +1553,17 @@ impl &[T]: ImmutableVector { } /// Reduce a vector from right to left #[inline] - pure fn foldr(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) } + pure fn foldr(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 #[inline] - pure fn map(f: fn(v: &T) -> U) -> ~[U] { map(self, f) } + pure fn map(f: fn(t: &T) -> U) -> ~[U] { map(self, f) } /** * Apply a function to the index and value of each element in the vector * and return the results */ - pure fn mapi(f: fn(uint, v: &T) -> U) -> ~[U] { + pure fn mapi(f: fn(uint, t: &T) -> U) -> ~[U] { mapi(self, f) } @@ -1580,7 +1583,7 @@ impl &[T]: ImmutableVector { * * If the vector is empty, true is returned. */ - pure fn alli(f: fn(uint, T) -> bool) -> bool { + pure fn alli(f: fn(uint, t: &T) -> bool) -> bool { alli(self, f) } /** @@ -1588,7 +1591,9 @@ impl &[T]: ImmutableVector { * of each result vector */ #[inline] - pure fn flat_map(f: fn(T) -> ~[U]) -> ~[U] { flat_map(self, f) } + pure fn flat_map(f: fn(t: &T) -> ~[U]) -> ~[U] { + flat_map(self, f) + } /** * Apply a function to each element of a vector and return the results * @@ -1596,7 +1601,7 @@ impl &[T]: ImmutableVector { * the resulting vector. */ #[inline] - pure fn filter_map(f: fn(T) -> Option) -> ~[U] { + pure fn filter_map(f: fn(t: &T) -> Option) -> ~[U] { filter_map(self, f) } } @@ -1610,10 +1615,16 @@ impl &[T]: ImmutableEqVector { * elements then none is returned. */ #[inline] - pure fn position(f: fn(T) -> bool) -> Option { position(self, f) } + pure fn position(f: fn(t: &T) -> bool) -> Option { + position(self, f) + } + /// Find the first index containing a matching value #[inline] - pure fn position_elem(x: T) -> Option { position_elem(self, x) } + pure fn position_elem(x: &T) -> Option { + position_elem(self, x) + } + /** * Find the last index matching some predicate * @@ -1622,15 +1633,21 @@ impl &[T]: ImmutableEqVector { * returned. If `f` matches no elements then none is returned. */ #[inline] - pure fn rposition(f: fn(T) -> bool) -> Option { rposition(self, f) } + pure fn rposition(f: fn(t: &T) -> bool) -> Option { + rposition(self, f) + } + /// Find the last index containing a matching value #[inline] - pure fn rposition_elem(x: T) -> Option { rposition_elem(self, x) } + pure fn rposition_elem(t: &T) -> Option { + rposition_elem(self, t) + } } trait ImmutableCopyableVector { - pure fn filter(f: fn(T) -> bool) -> ~[T]; - pure fn rfind(f: fn(T) -> bool) -> Option; + pure fn filter(f: fn(t: &T) -> bool) -> ~[T]; + + pure fn rfind(f: fn(t: &T) -> bool) -> Option; } /// Extension methods for vectors @@ -1643,7 +1660,10 @@ impl &[T]: ImmutableCopyableVector { * containing only those elements for which `f` returned true. */ #[inline] - pure fn filter(f: fn(T) -> bool) -> ~[T] { filter(self, f) } + pure fn filter(f: fn(t: &T) -> bool) -> ~[T] { + filter(self, f) + } + /** * Search for the last element that matches a given predicate * @@ -1652,16 +1672,28 @@ impl &[T]: ImmutableCopyableVector { * returned. If `f` matches no elements then none is returned. */ #[inline] - pure fn rfind(f: fn(T) -> bool) -> Option { rfind(self, f) } + pure fn rfind(f: fn(t: &T) -> bool) -> Option { rfind(self, f) } } trait MutableVector { fn push(&mut self, +t: T); - fn push_all_move(&mut self, -rhs: ~[const 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 swap_remove(&mut self, index: uint) -> T; + fn truncate(&mut self, newlen: uint); } trait MutableCopyableVector { 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); + fn grow_set(&mut self, index: uint, initval: &T, +val: T); +} + +trait MutableEqVector { + fn dedup(&mut self); } impl ~[T]: MutableVector { @@ -1669,15 +1701,53 @@ impl ~[T]: MutableVector { push(self, move t); } - fn push_all_move(&mut self, -rhs: ~[const T]) { + fn push_all_move(&mut self, +rhs: ~[T]) { push_all_move(self, move rhs); } + + fn pop(&mut self) -> T { + pop(self) + } + + fn shift(&mut self) -> T { + shift(self) + } + + fn unshift(&mut self, +x: T) { + unshift(self, x) + } + + fn swap_remove(&mut self, index: uint) -> T { + swap_remove(self, index) + } + + fn truncate(&mut self, newlen: uint) { + truncate(self, newlen); + } } impl ~[T]: MutableCopyableVector { fn push_all(&mut self, rhs: &[const T]) { push_all(self, rhs); } + + fn grow(&mut self, n: uint, initval: &T) { + grow(self, n, initval); + } + + fn grow_fn(&mut self, n: uint, op: iter::InitOp) { + grow_fn(self, n, op); + } + + fn grow_set(&mut self, index: uint, initval: &T, +val: T) { + grow_set(self, index, initval, val); + } +} + +impl ~[T]: MutableEqVector { + fn dedup(&mut self) { + dedup(self) + } } /// Unsafe operations @@ -1714,7 +1784,7 @@ mod raw { #[inline(always)] unsafe fn from_buf(ptr: *T, elts: uint) -> ~[T] { let mut dst = with_capacity(elts); - set_len(dst, elts); + set_len(&mut dst, elts); as_mut_buf(dst, |p_dst, _len_dst| ptr::memcpy(p_dst, ptr, elts)); move dst } @@ -1727,8 +1797,8 @@ mod raw { * the vector is actually the specified size. */ #[inline(always)] - unsafe fn set_len(&&v: ~[const T], new_len: uint) { - let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v)); + unsafe fn set_len(v: &mut ~[T], new_len: uint) { + let repr: **VecRepr = ::cast::transmute(v); (**repr).unboxed.fill = new_len * sys::size_of::(); } @@ -1742,22 +1812,22 @@ mod raw { * would also make any pointers to it invalid. */ #[inline(always)] - unsafe fn to_ptr(v: &[T]) -> *T { - let repr: **SliceRepr = ::cast::reinterpret_cast(&addr_of(v)); + unsafe fn to_ptr(+v: &[T]) -> *T { + let repr: **SliceRepr = ::cast::transmute(&v); return ::cast::reinterpret_cast(&addr_of((**repr).data)); } /** see `to_ptr()` */ #[inline(always)] - unsafe fn to_const_ptr(v: &[const T]) -> *const T { - let repr: **SliceRepr = ::cast::reinterpret_cast(&addr_of(v)); + unsafe fn to_const_ptr(+v: &[const T]) -> *const T { + let repr: **SliceRepr = ::cast::transmute(&v); return ::cast::reinterpret_cast(&addr_of((**repr).data)); } /** see `to_ptr()` */ #[inline(always)] - unsafe fn to_mut_ptr(v: &[mut T]) -> *mut T { - let repr: **SliceRepr = ::cast::reinterpret_cast(&addr_of(v)); + unsafe fn to_mut_ptr(+v: &[mut T]) -> *mut T { + let repr: **SliceRepr = ::cast::transmute(&v); return ::cast::reinterpret_cast(&addr_of((**repr).data)); } @@ -1782,10 +1852,12 @@ mod raw { } /** - * Unchecked vector index assignment. + * Unchecked vector index assignment. Does not drop the + * old value and hence is only suitable when the vector + * is newly allocated. */ #[inline(always)] - unsafe fn set(v: &[mut T], i: uint, +val: T) { + unsafe fn init_elem(v: &[mut T], i: uint, +val: T) { let mut box = Some(move val); do as_mut_buf(v) |p, _len| { let mut box2 = None; @@ -1963,17 +2035,17 @@ mod tests { fn square_ref(n: &uint) -> uint { return square(*n); } - pure fn is_three(&&n: uint) -> bool { return n == 3u; } + pure fn is_three(n: &uint) -> bool { return *n == 3u; } - pure fn is_odd(&&n: uint) -> bool { return n % 2u == 1u; } + pure fn is_odd(n: &uint) -> bool { return *n % 2u == 1u; } - pure fn is_equal(&&x: uint, &&y:uint) -> bool { return x == y; } + pure fn is_equal(x: &uint, y:&uint) -> bool { return *x == *y; } - fn square_if_odd(&&n: uint) -> Option { - return if n % 2u == 1u { Some(n * n) } else { None }; + fn square_if_odd(n: &uint) -> Option { + 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() { @@ -2103,7 +2175,7 @@ mod tests { fn test_pop() { // Test on-stack pop. let mut v = ~[1, 2, 3]; - let mut e = pop(v); + let mut e = v.pop(); assert (len(v) == 2u); assert (v[0] == 1); assert (v[1] == 2); @@ -2111,7 +2183,7 @@ mod tests { // Test on-heap pop. v = ~[1, 2, 3, 4, 5]; - e = pop(v); + e = v.pop(); assert (len(v) == 4u); assert (v[0] == 1); assert (v[1] == 2); @@ -2123,11 +2195,11 @@ mod tests { #[test] fn test_swap_remove() { let mut v = ~[1, 2, 3, 4, 5]; - let mut e = swap_remove(v, 0); + let mut e = v.swap_remove(0); assert (len(v) == 4); assert e == 1; assert (v[0] == 5); - e = swap_remove(v, 3); + e = v.swap_remove(3); assert (len(v) == 3); assert e == 4; assert (v[0] == 5); @@ -2140,11 +2212,11 @@ mod tests { // Tests that we don't accidentally run destructors twice. let mut v = ~[::private::exclusive(()), ::private::exclusive(()), ::private::exclusive(())]; - let mut _e = swap_remove(v, 0); + let mut _e = v.swap_remove(0); assert (len(v) == 2); - _e = swap_remove(v, 1); + _e = v.swap_remove(1); assert (len(v) == 1); - _e = swap_remove(v, 0); + _e = v.swap_remove(0); assert (len(v) == 0); } @@ -2167,13 +2239,13 @@ mod tests { fn test_grow() { // Test on-stack grow(). let mut v = ~[]; - grow(v, 2u, 1); + v.grow(2u, &1); assert (len(v) == 2u); assert (v[0] == 1); assert (v[1] == 1); // Test on-heap grow(). - grow(v, 3u, 2); + v.grow(3u, &2); assert (len(v) == 5u); assert (v[0] == 1); assert (v[1] == 1); @@ -2185,7 +2257,7 @@ mod tests { #[test] fn test_grow_fn() { let mut v = ~[]; - grow_fn(v, 3u, square); + v.grow_fn(3u, square); assert (len(v) == 3u); assert (v[0] == 0u); assert (v[1] == 1u); @@ -2195,7 +2267,7 @@ mod tests { #[test] fn test_grow_set() { let mut v = ~[1, 2, 3]; - grow_set(v, 4u, 4, 5); + v.grow_set(4u, &4, 5); assert (len(v) == 5u); assert (v[0] == 1); assert (v[1] == 2); @@ -2207,7 +2279,7 @@ mod tests { #[test] fn test_truncate() { let mut v = ~[@6,@5,@4]; - truncate(v, 1); + v.truncate(1); assert(v.len() == 1); assert(*(v[0]) == 6); // If the unsafe block didn't drop things properly, we blow up here. @@ -2217,7 +2289,7 @@ mod tests { fn test_dedup() { fn case(-a: ~[uint], -b: ~[uint]) { let mut v = a; - dedup(v); + v.dedup(); assert(v == b); } case(~[], ~[]); @@ -2233,11 +2305,11 @@ mod tests { #[test] fn test_dedup_unique() { let mut v0 = ~[~1, ~1, ~2, ~3]; - dedup(v0); + v0.dedup(); let mut v1 = ~[~1, ~2, ~2, ~3]; - dedup(v1); + v1.dedup(); let mut v2 = ~[~1, ~2, ~3, ~3]; - dedup(v2); + v2.dedup(); /* * If the ~pointers were leaked or otherwise misused, valgrind and/or * rustrt should raise errors. @@ -2247,11 +2319,11 @@ mod tests { #[test] fn test_dedup_shared() { let mut v0 = ~[@1, @1, @2, @3]; - dedup(v0); + v0.dedup(); let mut v1 = ~[@1, @2, @2, @3]; - dedup(v1); + v1.dedup(); let mut v2 = ~[@1, @2, @3, @3]; - dedup(v2); + v2.dedup(); /* * If the @pointers were leaked or otherwise misused, valgrind and/or * rustrt should raise errors. @@ -2281,7 +2353,7 @@ mod tests { #[test] fn test_map2() { - fn times(&&x: int, &&y: int) -> int { return x * y; } + fn times(x: &int, y: &int) -> int { return *x * *y; } let f = times; let v0 = ~[1, 2, 3, 4, 5]; let v1 = ~[5, 4, 3, 2, 1]; @@ -2307,9 +2379,9 @@ mod tests { assert (w[1] == 9u); assert (w[2] == 25u); - fn halve(&&i: int) -> Option { - if i % 2 == 0 { - return option::Some::(i / 2); + fn halve(i: &int) -> Option { + if *i % 2 == 0 { + return option::Some::(*i / 2); } else { return option::None::; } } fn halve_for_sure(i: &int) -> int { return *i / 2; } @@ -2345,8 +2417,8 @@ mod tests { #[test] fn test_foldl2() { - fn sub(&&a: int, &&b: int) -> int { - a - b + fn sub(+a: int, b: &int) -> int { + a - *b } let mut v = ~[1, 2, 3, 4]; let sum = foldl(0, v, sub); @@ -2355,8 +2427,8 @@ mod tests { #[test] fn test_foldr() { - fn sub(&&a: int, &&b: int) -> int { - a - b + fn sub(a: &int, +b: int) -> int { + *a - b } let mut v = ~[1, 2, 3, 4]; let sum = foldr(v, 0, sub); @@ -2419,23 +2491,23 @@ mod tests { } #[test] - fn test_permute() { + fn test_each_permutation() { let mut results: ~[~[int]]; results = ~[]; - permute(~[], |v| results.push(copy v)); + for each_permutation(~[]) |v| { results.push(from_slice(v)); } assert results == ~[~[]]; results = ~[]; - permute(~[7], |v| results.push(copy v)); + for each_permutation(~[7]) |v| { results.push(from_slice(v)); } assert results == ~[~[7]]; results = ~[]; - permute(~[1,1], |v| results.push(copy v)); + for each_permutation(~[1,1]) |v| { results.push(from_slice(v)); } assert results == ~[~[1,1],~[1,1]]; results = ~[]; - permute(~[5,2,0], |v| results.push(copy v)); + for each_permutation(~[5,2,0]) |v| { results.push(from_slice(v)); } assert results == ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]]; } @@ -2487,19 +2559,19 @@ mod tests { #[test] fn test_position_elem() { - assert position_elem(~[], 1).is_none(); + assert position_elem(~[], &1).is_none(); let v1 = ~[1, 2, 3, 3, 2, 5]; - assert position_elem(v1, 1) == Some(0u); - assert position_elem(v1, 2) == Some(1u); - assert position_elem(v1, 5) == Some(5u); - assert position_elem(v1, 4).is_none(); + assert position_elem(v1, &1) == Some(0u); + assert position_elem(v1, &2) == Some(1u); + assert position_elem(v1, &5) == Some(5u); + assert position_elem(v1, &4).is_none(); } #[test] fn test_position() { - fn less_than_three(&&i: int) -> bool { return i < 3; } - fn is_eighteen(&&i: int) -> bool { return i == 18; } + fn less_than_three(i: &int) -> bool { return *i < 3; } + fn is_eighteen(i: &int) -> bool { return *i == 18; } assert position(~[], less_than_three).is_none(); @@ -2512,7 +2584,7 @@ mod tests { fn test_position_between() { assert position_between(~[], 0u, 0u, f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert position_between(v, 0u, 0u, f).is_none(); @@ -2540,8 +2612,8 @@ mod tests { fn test_find() { assert find(~[], f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } - fn g(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'd' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } + fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert find(v, f) == Some((1, 'b')); @@ -2552,7 +2624,7 @@ mod tests { fn test_find_between() { assert find_between(~[], 0u, 0u, f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert find_between(v, 0u, 0u, f).is_none(); @@ -2580,8 +2652,8 @@ mod tests { fn test_rposition() { assert find(~[], f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } - fn g(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'd' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } + fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert position(v, f) == Some(1u); @@ -2592,7 +2664,7 @@ mod tests { fn test_rposition_between() { assert rposition_between(~[], 0u, 0u, f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert rposition_between(v, 0u, 0u, f).is_none(); @@ -2620,8 +2692,8 @@ mod tests { fn test_rfind() { assert rfind(~[], f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } - fn g(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'd' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } + fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert rfind(v, f) == Some((3, 'b')); @@ -2632,7 +2704,7 @@ mod tests { fn test_rfind_between() { assert rfind_between(~[], 0u, 0u, f).is_none(); - fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' } + fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert rfind_between(v, 0u, 0u, f).is_none(); @@ -2692,7 +2764,7 @@ mod tests { #[test] fn test_split() { - fn f(&&x: int) -> bool { x == 3 } + fn f(x: &int) -> bool { *x == 3 } assert split(~[], f) == ~[]; assert split(~[1, 2], f) == ~[~[1, 2]]; @@ -2703,7 +2775,7 @@ mod tests { #[test] fn test_splitn() { - fn f(&&x: int) -> bool { x == 3 } + fn f(x: &int) -> bool { *x == 3 } assert splitn(~[], 1u, f) == ~[]; assert splitn(~[1, 2], 1u, f) == ~[~[1, 2]]; @@ -2715,7 +2787,7 @@ mod tests { #[test] fn test_rsplit() { - fn f(&&x: int) -> bool { x == 3 } + fn f(x: &int) -> bool { *x == 3 } assert rsplit(~[], f) == ~[]; assert rsplit(~[1, 2], f) == ~[~[1, 2]]; @@ -2725,7 +2797,7 @@ mod tests { #[test] fn test_rsplitn() { - fn f(&&x: int) -> bool { x == 3 } + fn f(x: &int) -> bool { *x == 3 } assert rsplitn(~[], 1u, f) == ~[]; assert rsplitn(~[1, 2], 1u, f) == ~[~[1, 2]]; @@ -2748,9 +2820,9 @@ mod tests { #[test] fn test_connect() { - assert connect(~[], 0) == ~[]; - assert connect(~[~[1], ~[2, 3]], 0) == ~[1, 0, 2, 3]; - assert connect(~[~[1], ~[2], ~[3]], 0) == ~[1, 0, 2, 0, 3]; + assert connect(~[], &0) == ~[]; + assert connect(~[~[1], ~[2, 3]], &0) == ~[1, 0, 2, 3]; + assert connect(~[~[1], ~[2], ~[3]], &0) == ~[1, 0, 2, 0, 3]; } #[test] @@ -2796,7 +2868,7 @@ mod tests { #[test] fn test_unshift() { let mut x = ~[1, 2, 3]; - unshift(x, 0); + x.unshift(0); assert x == ~[0, 1, 2, 3]; } @@ -2804,10 +2876,10 @@ mod tests { fn test_capacity() { let mut v = ~[0u64]; reserve(&mut v, 10u); - assert capacity(v) == 10u; + assert capacity(&v) == 10u; let mut v = ~[0u32]; reserve(&mut v, 10u); - assert capacity(v) == 10u; + assert capacity(&v) == 10u; } #[test] @@ -3012,7 +3084,7 @@ mod tests { #[should_fail] fn test_grow_fn_fail() { let mut v = ~[]; - do grow_fn(v, 100) |i| { + do v.grow_fn(100) |i| { if i == 50 { fail } @@ -3318,7 +3390,7 @@ mod tests { fn test_permute_fail() { let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)]; let mut i = 0; - do permute(v) |_elt| { + for each_permutation(v) |_elt| { if i == 2 { fail } diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 3f6bcd31a73..59de3631118 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -217,7 +217,7 @@ impl Writer { } fn end_tag() { - let last_size_pos = vec::pop::(self.size_positions); + let last_size_pos = self.size_positions.pop(); let cur_pos = self.writer.tell(); self.writer.seek(last_size_pos as int, io::SeekSet); let size = (cur_pos - last_size_pos - 4u); diff --git a/src/libstd/ebml2.rs b/src/libstd/ebml2.rs index 496010d579e..21a7d7817c9 100644 --- a/src/libstd/ebml2.rs +++ b/src/libstd/ebml2.rs @@ -226,7 +226,7 @@ impl Serializer { } fn end_tag() { - let last_size_pos = vec::pop::(self.size_positions); + let last_size_pos = self.size_positions.pop(); let cur_pos = self.writer.tell(); self.writer.seek(last_size_pos as int, io::SeekSet); let size = (cur_pos - last_size_pos - 4u); diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 8d27ea5783b..a04eadb7732 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -428,9 +428,8 @@ fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> { let vals = opt_vals(mm, nm); if vec::len::(vals) == 0u { return None::<~str>; } return match vals[0] { - Val(copy s) => - Some::<~str>(s), - _ => None::<~str> + Val(copy s) => Some(s), + _ => None }; } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 059b5c22545..247c13396d0 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -696,7 +696,7 @@ priv impl Deserializer { fn pop(&self) -> &self/Json { if self.stack.len() == 0 { self.stack.push(&self.json); } - vec::pop(self.stack) + self.stack.pop() } } diff --git a/src/libstd/list.rs b/src/libstd/list.rs index 1568c6c099f..2a7019f5a58 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -13,7 +13,7 @@ enum List { /// Cregate a list from a vector fn from_vec(v: &[T]) -> @List { - vec::foldr(v, @Nil::, |h, t| @Cons(h, t)) + vec::foldr(v, @Nil::, |h, t| @Cons(*h, t)) } /** diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index 202ca548d6b..5b2ea0a84a6 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -163,7 +163,7 @@ mod v4 { if vec::len(parts) != 4u { result::Err(fmt!("'%s' doesn't have 4 parts", ip)) } - else if vec::contains(parts, 256u) { + else if vec::contains(parts, &256u) { result::Err(fmt!("invalid octal in addr '%s'", ip)) } else { diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index f8347be3d08..699fec961c4 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -800,7 +800,7 @@ impl TcpSocketBuf: io::Reader { if self.read(bytes, 1u) == 0 { fail } else { bytes[0] as int } } fn unread_byte(amt: int) { - vec::unshift((*(self.data)).buf, amt as u8); + self.data.buf.unshift(amt as u8); } fn eof() -> bool { false // noop diff --git a/src/libstd/par.rs b/src/libstd/par.rs index a0c9a1b92fe..9cfcd8c2acb 100644 --- a/src/libstd/par.rs +++ b/src/libstd/par.rs @@ -123,17 +123,17 @@ pub fn alli(xs: ~[A], f: fn~(uint, A) -> bool) -> bool { do vec::all(map_slices(xs, || { fn~(base: uint, slice : &[A], copy f) -> bool { vec::alli(slice, |i, x| { - f(i + base, x) + f(i + base, *x) }) } - })) |x| { x } + })) |x| { *x } } /// Returns true if the function holds for any elements in the vector. pub fn any(xs: ~[A], f: fn~(A) -> bool) -> bool { do vec::any(map_slices(xs, || { fn~(_base : uint, slice: &[A], copy f) -> bool { - vec::any(slice, |x| f(x)) + vec::any(slice, |x| f(*x)) } - })) |x| { x } + })) |x| { *x } } diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index e3927ef188c..1100485e7f1 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -30,7 +30,7 @@ fn mk() -> SmallIntMap { #[inline(always)] fn insert(self: SmallIntMap, key: uint, +val: T) { //io::println(fmt!("%?", key)); - self.v.grow_set_elt(key, None, Some(val)); + self.v.grow_set_elt(key, &None, Some(val)); } /** diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 9ea43177cea..691f0e840e6 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -358,7 +358,7 @@ fn filter_tests(opts: &TestOpts, } else { return option::None; } } - vec::filter_map(filtered, |x| filter_fn(&x, filter_str)) + vec::filter_map(filtered, |x| filter_fn(x, filter_str)) }; // Maybe pull out the ignored test and unignore them @@ -374,7 +374,7 @@ fn filter_tests(opts: &TestOpts, } else { return option::None; } }; - vec::filter_map(filtered, |x| filter(&x)) + vec::filter_map(filtered, |x| filter(x)) }; // Sort the tests alphabetically diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index b6d4c2d0fe3..d05c6eadaf6 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -278,7 +278,7 @@ fn map_item(i: @item, cx: ctx, v: vt) { _ => cx.path.push(path_name(i.ident)) } visit::visit_item(i, cx, v); - vec::pop(cx.path); + cx.path.pop(); } fn map_struct_def(struct_def: @ast::struct_def, parent_node: ast_node, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index a2c935ea6f4..2431947184d 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -275,14 +275,14 @@ fn ident_to_path(s: span, +i: ident) -> @path { rp: None, types: ~[]} } -pure fn is_unguarded(&&a: arm) -> bool { +pure fn is_unguarded(a: &arm) -> bool { match a.guard { None => true, _ => false } } -pure fn unguarded_pat(a: arm) -> Option<~[@pat]> { +pure fn unguarded_pat(a: &arm) -> Option<~[@pat]> { if is_unguarded(a) { Some(/* FIXME (#2543) */ copy a.pats) } else { None } } diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 7ef34d8eb0b..d08edd7af1d 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -163,9 +163,9 @@ fn get_name_value_str_pair(item: @ast::meta_item) -> Option<(~str, ~str)> { fn find_attrs_by_name(attrs: ~[ast::attribute], name: ~str) -> ~[ast::attribute] { let filter = ( - fn@(a: ast::attribute) -> Option { - if get_attr_name(a) == name { - option::Some(a) + fn@(a: &ast::attribute) -> Option { + if get_attr_name(*a) == name { + option::Some(*a) } else { option::None } } ); @@ -175,9 +175,9 @@ fn find_attrs_by_name(attrs: ~[ast::attribute], name: ~str) -> /// Searcha list of meta items and return only those with a specific name fn find_meta_items_by_name(metas: ~[@ast::meta_item], name: ~str) -> ~[@ast::meta_item] { - let filter = fn@(&&m: @ast::meta_item) -> Option<@ast::meta_item> { - if get_meta_item_name(m) == name { - option::Some(m) + let filter = fn@(m: &@ast::meta_item) -> Option<@ast::meta_item> { + if get_meta_item_name(*m) == name { + option::Some(*m) } else { option::None } }; return vec::filter_map(metas, filter); @@ -289,8 +289,8 @@ fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ~str) -> ~[@ast::meta_item] { return vec::filter_map(items, |item| { - if get_meta_item_name(item) != name { - option::Some(/* FIXME (#2543) */ copy item) + if get_meta_item_name(*item) != name { + option::Some(/* FIXME (#2543) */ copy *item) } else { option::None } diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs index 4ebb8501041..fa14d3b5e99 100644 --- a/src/libsyntax/ext/auto_serialize.rs +++ b/src/libsyntax/ext/auto_serialize.rs @@ -90,8 +90,8 @@ fn expand(cx: ext_ctxt, span: span, _mitem: ast::meta_item, in_items: ~[@ast::item]) -> ~[@ast::item] { - fn not_auto_serialize(a: ast::attribute) -> bool { - attr::get_attr_name(a) != ~"auto_serialize" + fn not_auto_serialize(a: &ast::attribute) -> bool { + attr::get_attr_name(*a) != ~"auto_serialize" } fn filter_attrs(item: @ast::item) -> @ast::item { @@ -102,12 +102,12 @@ fn expand(cx: ext_ctxt, do vec::flat_map(in_items) |in_item| { match in_item.node { ast::item_ty(ty, tps) => { - vec::append(~[filter_attrs(in_item)], + vec::append(~[filter_attrs(*in_item)], ty_fns(cx, in_item.ident, ty, tps)) } ast::item_enum(enum_definition, tps) => { - vec::append(~[filter_attrs(in_item)], + vec::append(~[filter_attrs(*in_item)], enum_fns(cx, in_item.ident, in_item.span, enum_definition.variants, tps)) } @@ -116,7 +116,7 @@ fn expand(cx: ext_ctxt, cx.span_err(span, ~"#[auto_serialize] can only be \ applied to type and enum \ definitions"); - ~[in_item] + ~[*in_item] } } } diff --git a/src/libsyntax/ext/auto_serialize2.rs b/src/libsyntax/ext/auto_serialize2.rs index b51184eefd8..099ba67713f 100644 --- a/src/libsyntax/ext/auto_serialize2.rs +++ b/src/libsyntax/ext/auto_serialize2.rs @@ -75,8 +75,8 @@ fn expand(cx: ext_ctxt, span: span, _mitem: ast::meta_item, in_items: ~[@ast::item]) -> ~[@ast::item] { - fn not_auto_serialize2(a: ast::attribute) -> bool { - attr::get_attr_name(a) != ~"auto_serialize2" + fn not_auto_serialize2(a: &ast::attribute) -> bool { + attr::get_attr_name(*a) != ~"auto_serialize2" } fn filter_attrs(item: @ast::item) -> @ast::item { @@ -88,19 +88,19 @@ fn expand(cx: ext_ctxt, match item.node { ast::item_ty(@{node: ast::ty_rec(fields), _}, tps) => { ~[ - filter_attrs(item), + filter_attrs(*item), mk_rec_impl(cx, item.span, item.ident, fields, tps), ] }, ast::item_class(@{ fields, _}, tps) => { ~[ - filter_attrs(item), + filter_attrs(*item), mk_struct_impl(cx, item.span, item.ident, fields, tps), ] }, ast::item_enum(enum_def, tps) => { ~[ - filter_attrs(item), + filter_attrs(*item), mk_enum_impl(cx, item.span, item.ident, enum_def, tps), ] }, @@ -108,7 +108,7 @@ fn expand(cx: ext_ctxt, cx.span_err(span, ~"#[auto_serialize2] can only be applied \ to structs, record types, and enum \ definitions"); - ~[item] + ~[*item] } } } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 566cdc4fa21..5f4d86b9860 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -161,7 +161,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess, fn print_backtrace() { } fn backtrace() -> expn_info { self.backtrace } fn mod_push(i: ast::ident) { self.mod_path.push(i); } - fn mod_pop() { vec::pop(self.mod_path); } + fn mod_pop() { self.mod_path.pop(); } fn mod_path() -> ~[ast::ident] { return self.mod_path; } fn bt_push(ei: codemap::expn_info_) { match ei { diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index dbe475c1b50..22e2cfcde6b 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -144,7 +144,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, // decorated with "item decorators", then use that function to transform // the item into a new set of items. let new_items = do vec::flat_map(module_.items) |item| { - do vec::foldr(item.attrs, ~[item]) |attr, items| { + do vec::foldr(item.attrs, ~[*item]) |attr, items| { let mname = match attr.node.value.node { ast::meta_word(n) => n, ast::meta_name_value(n, _) => n, @@ -160,7 +160,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt, } }; - return {items: new_items,.. module_}; + return {items: new_items, ..module_}; } diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index f93fa830f92..b9b1484ce5a 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -47,7 +47,7 @@ impl message: gen_send { let arg_names = tys.mapi(|i, _ty| cx.ident_of(~"x_"+i.to_str())); let args_ast = (arg_names, tys).map( - |n, t| cx.arg_mode(n, t, ast::by_copy) + |n, t| cx.arg_mode(*n, *t, ast::by_copy) ); let pipe_ty = cx.ty_path_ast_builder( @@ -129,7 +129,7 @@ impl message: gen_send { let arg_names = tys.mapi(|i, _ty| (~"x_" + i.to_str())); let args_ast = (arg_names, tys).map( - |n, t| cx.arg_mode(cx.ident_of(n), t, ast::by_copy) + |n, t| cx.arg_mode(cx.ident_of(*n), *t, ast::by_copy) ); let args_ast = vec::append( diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs index 51239754635..e16e1c55349 100644 --- a/src/libsyntax/ext/simplext.rs +++ b/src/libsyntax/ext/simplext.rs @@ -307,7 +307,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint], while idx < rc { idx_path.push(idx); res.push(recur(repeat_me)); // whew! - vec::pop(*idx_path); + idx_path.pop(); idx += 1u; } } diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 737694337e3..16e3454ca2c 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -219,7 +219,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) /* we append new items to this while we go */ while cur_eis.len() > 0u { /* for each Earley Item */ - let mut ei = vec::pop(cur_eis); + let mut ei = cur_eis.pop(); let idx = ei.idx; let len = ei.elts.len(); @@ -350,13 +350,13 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher]) } else if (next_eis.len() > 0u) { /* Now process the next token */ while(next_eis.len() > 0u) { - cur_eis.push(vec::pop(next_eis)); + cur_eis.push(next_eis.pop()); } rdr.next_token(); } else /* bb_eis.len() == 1 */ { let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE); - let ei = vec::pop(bb_eis); + let ei = bb_eis.pop(); match ei.elts[ei.idx].node { match_nonterminal(_, name, idx) => { ei.matches[idx].push(@matched_nonterminal( diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 558593579bf..a8a41cca6cb 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -82,13 +82,13 @@ pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader { pure fn lookup_cur_matched_by_matched(r: tt_reader, start: @named_match) -> @named_match { - pure fn red(&&ad: @named_match, &&idx: uint) -> @named_match { + pure fn red(+ad: @named_match, idx: &uint) -> @named_match { match *ad { matched_nonterminal(_) => { // end of the line; duplicate henceforth ad } - matched_seq(ads, _) => ads[idx] + matched_seq(ads, _) => ads[*idx] } } vec::foldl(start, r.repeat_idx, red) @@ -122,8 +122,8 @@ fn lockstep_iter_size(t: token_tree, r: tt_reader) -> lis { } match t { tt_delim(tts) | tt_seq(_, tts, _, _) => { - vec::foldl(lis_unconstrained, tts, {|lis, tt| - lis_merge(lis, lockstep_iter_size(tt, r), r) }) + vec::foldl(lis_unconstrained, tts, |lis, tt| + lis_merge(lis, lockstep_iter_size(*tt, r), r)) } tt_tok(*) => lis_unconstrained, tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) { @@ -148,7 +148,8 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} { } tt_frame_up(Some(tt_f)) => { if r.cur.dotdotdoted { - vec::pop(r.repeat_idx); vec::pop(r.repeat_len); + r.repeat_idx.pop(); + r.repeat_len.pop(); } r.cur = tt_f; diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 4f3dafcb21b..088df01985e 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -552,7 +552,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ { // ...nor do modules fn noop_fold_mod(m: _mod, fld: ast_fold) -> _mod { return {view_items: vec::map(m.view_items, |x| fld.fold_view_item(*x)), - items: vec::filter_map(m.items, |x| fld.fold_item(x))}; + items: vec::filter_map(m.items, |x| fld.fold_item(*x))}; } fn noop_fold_foreign_mod(nm: foreign_mod, fld: ast_fold) -> foreign_mod { diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 5d1067da762..240c9f34c81 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1111,7 +1111,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) { ast::expr_call(func, args, has_block) => { let mut base_args = args; let blk = if has_block { - let blk_arg = vec::pop(base_args); + let blk_arg = base_args.pop(); match blk_arg.node { ast::expr_loop_body(_) => { head(s, ~"for"); } ast::expr_do_body(_) => { head(s, ~"do"); } diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs index 38ce7a4fbac..8b1202e632e 100644 --- a/src/rustc/driver/rustc.rs +++ b/src/rustc/driver/rustc.rs @@ -122,7 +122,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) { logging::console_off(); let mut args = args; - let binary = vec::shift(args); + let binary = args.shift(); if vec::len(args) == 0u { usage(binary); return; } diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs index 7e0d9ec2e86..4577b54fb5c 100644 --- a/src/rustc/front/config.rs +++ b/src/rustc/front/config.rs @@ -50,13 +50,12 @@ fn filter_view_item(cx: ctxt, &&view_item: @ast::view_item fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod { - let item_filter = |a| filter_item(cx, a); - let filtered_items = vec::filter_map(m.items, item_filter); - let view_item_filter = |a| filter_view_item(cx, a); - let filtered_view_items = vec::filter_map(m.view_items, view_item_filter); + let filtered_items = vec::filter_map(m.items, |a| filter_item(cx, *a)); + let filtered_view_items = vec::filter_map(m.view_items, + |a| filter_view_item(cx, *a)); return { view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)), - items: vec::filter_map(filtered_items, |x| fld.fold_item(x)) + items: vec::filter_map(filtered_items, |x| fld.fold_item(*x)) }; } @@ -69,11 +68,10 @@ fn filter_foreign_item(cx: ctxt, &&item: @ast::foreign_item) -> fn fold_foreign_mod(cx: ctxt, nm: ast::foreign_mod, fld: fold::ast_fold) -> ast::foreign_mod { - let item_filter = |a| filter_foreign_item(cx, a); - let filtered_items = vec::filter_map(nm.items, item_filter); - let view_item_filter = |a| filter_view_item(cx, a); - let filtered_view_items = vec::filter_map( - nm.view_items, view_item_filter); + let filtered_items = vec::filter_map(nm.items, + |a| filter_foreign_item(cx, *a)); + let filtered_view_items = vec::filter_map(nm.view_items, + |a| filter_view_item(cx, *a)); return { sort: nm.sort, view_items: vec::map(filtered_view_items, |x| fld.fold_view_item(*x)), @@ -100,8 +98,7 @@ fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) -> fn fold_block(cx: ctxt, b: ast::blk_, fld: fold::ast_fold) -> ast::blk_ { - let filter = |a| filter_stmt(cx, a); - let filtered_stmts = vec::filter_map(b.stmts, filter); + let filtered_stmts = vec::filter_map(b.stmts, |a| filter_stmt(cx, *a)); return {view_items: b.view_items, stmts: vec::map(filtered_stmts, |x| fld.fold_stmt(*x)), expr: option::map(&b.expr, |x| fld.fold_expr(*x)), @@ -136,7 +133,7 @@ fn metas_in_cfg(cfg: ast::crate_cfg, metas: ~[@ast::meta_item]) -> bool { // so we can match against them. This is the list of configurations for // which the item is valid let cfg_metas = vec::concat(vec::filter_map(cfg_metas, - |&&i| attr::get_meta_item_list(i) )); + |i| attr::get_meta_item_list(*i))); let has_cfg_metas = vec::len(cfg_metas) > 0u; if !has_cfg_metas { return true; } diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs index 55d71ab6950..952d7b9ab79 100644 --- a/src/rustc/front/test.rs +++ b/src/rustc/front/test.rs @@ -81,8 +81,8 @@ fn fold_mod(cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod { } let mod_nomain = - {view_items: m.view_items, items: vec::filter_map(m.items, - |i| nomain(cx, i))}; + {view_items: m.view_items, + items: vec::filter_map(m.items, |i| nomain(cx, *i))}; return fold::noop_fold_mod(mod_nomain, fld); } @@ -122,7 +122,7 @@ fn fold_item(cx: test_ctxt, &&i: @ast::item, fld: fold::ast_fold) -> } let res = fold::noop_fold_item(i, fld); - vec::pop(cx.path); + cx.path.pop(); return res; } @@ -152,7 +152,7 @@ fn is_ignored(cx: test_ctxt, i: @ast::item) -> bool { let ignoreattrs = attr::find_attrs_by_name(i.attrs, ~"ignore"); let ignoreitems = attr::attr_metas(ignoreattrs); let cfg_metas = vec::concat(vec::filter_map(ignoreitems, - |&&i| attr::get_meta_item_list(i) )); + |i| attr::get_meta_item_list(*i))); return if vec::is_not_empty(ignoreitems) { config::metas_in_cfg(cx.crate.node.config, cfg_metas) } else { diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs index 49e79e009da..483f7ea06a9 100644 --- a/src/rustc/metadata/cstore.rs +++ b/src/rustc/metadata/cstore.rs @@ -114,7 +114,7 @@ fn iter_crate_data(cstore: cstore, i: fn(ast::crate_num, crate_metadata)) { } fn add_used_crate_file(cstore: cstore, lib: &Path) { - if !vec::contains(p(cstore).used_crate_files, copy *lib) { + if !vec::contains(p(cstore).used_crate_files, lib) { p(cstore).used_crate_files.push(copy *lib); } } @@ -126,7 +126,7 @@ fn get_used_crate_files(cstore: cstore) -> ~[Path] { fn add_used_library(cstore: cstore, lib: ~str) -> bool { assert lib != ~""; - if vec::contains(p(cstore).used_libraries, lib) { return false; } + if vec::contains(p(cstore).used_libraries, &lib) { return false; } p(cstore).used_libraries.push(lib); return true; } diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index d7fd8036c46..0e6bc2aee15 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -980,7 +980,7 @@ fn get_crate_module_paths(intr: @ident_interner, cdata: cmd) res.push((did, path)); } return do vec::filter(res) |x| { - let (_, xp) = x; + let (_, xp) = *x; mods.contains_key(xp) } } diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs index 841d54c6b0d..b2469718140 100644 --- a/src/rustc/middle/borrowck/check_loans.rs +++ b/src/rustc/middle/borrowck/check_loans.rs @@ -527,7 +527,7 @@ impl check_loan_ctxt { do vec::iter2(args, arg_tys) |arg, arg_ty| { match ty::resolved_mode(self.tcx(), arg_ty.mode) { ast::by_move => { - self.check_move_out(arg); + self.check_move_out(*arg); } ast::by_mutbl_ref | ast::by_ref | ast::by_copy | ast::by_val => { diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs index b3f846d47fd..85eae29529f 100644 --- a/src/rustc/middle/borrowck/gather_loans.rs +++ b/src/rustc/middle/borrowck/gather_loans.rs @@ -116,11 +116,11 @@ fn req_loans_in_expr(ex: @ast::expr, do vec::iter2(args, arg_tys) |arg, arg_ty| { match ty::resolved_mode(self.tcx(), arg_ty.mode) { ast::by_mutbl_ref => { - let arg_cmt = self.bccx.cat_expr(arg); + let arg_cmt = self.bccx.cat_expr(*arg); self.guarantee_valid(arg_cmt, m_mutbl, scope_r); } ast::by_ref => { - let arg_cmt = self.bccx.cat_expr(arg); + let arg_cmt = self.bccx.cat_expr(*arg); self.guarantee_valid(arg_cmt, m_imm, scope_r); } ast::by_val => { diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs index a3e85ac56c3..efbeb490db9 100644 --- a/src/rustc/middle/check_alt.rs +++ b/src/rustc/middle/check_alt.rs @@ -195,7 +195,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful { } } Some(ctor) => { - match is_useful(tcx, vec::filter_map(m, |r| default(tcx, r) ), + match is_useful(tcx, vec::filter_map(m, |r| default(tcx, *r) ), vec::tail(v)) { useful_ => useful(left_ty, ctor), u => u @@ -212,7 +212,7 @@ fn is_useful(tcx: ty::ctxt, m: matrix, v: ~[@pat]) -> useful { fn is_useful_specialized(tcx: ty::ctxt, m: matrix, v: ~[@pat], ctor: ctor, arity: uint, lty: ty::t) -> useful { - let ms = vec::filter_map(m, |r| specialize(tcx, r, ctor, arity, lty) ); + let ms = vec::filter_map(m, |r| specialize(tcx, *r, ctor, arity, lty) ); let could_be_useful = is_useful( tcx, ms, specialize(tcx, v, ctor, arity, lty).get()); match could_be_useful { @@ -269,7 +269,9 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option { let mut found = ~[]; for m.each |r| { do option::iter(&pat_ctor_id(tcx, r[0])) |id| { - if !vec::contains(found, *id) { found.push(*id); } + if !vec::contains(found, id) { + found.push(*id); + } } } let variants = ty::enum_variants(tcx, eid); diff --git a/src/rustc/middle/const_eval.rs b/src/rustc/middle/const_eval.rs index 463bf502036..5def18cacc3 100644 --- a/src/rustc/middle/const_eval.rs +++ b/src/rustc/middle/const_eval.rs @@ -41,7 +41,7 @@ enum constness { } fn join(a: constness, b: constness) -> constness { - match (a,b) { + match (a, b) { (integral_const, integral_const) => integral_const, (integral_const, general_const) | (general_const, integral_const) @@ -51,7 +51,7 @@ fn join(a: constness, b: constness) -> constness { } fn join_all(cs: &[constness]) -> constness { - vec::foldl(integral_const, cs, join) + vec::foldl(integral_const, cs, |a, b| join(a, *b)) } fn classify(e: @expr, diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs index 15a7d8f52b1..b1323d7fc93 100644 --- a/src/rustc/middle/kind.rs +++ b/src/rustc/middle/kind.rs @@ -273,7 +273,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt) { *bounds, (*bounds).len()); } do vec::iter2(*ts, *bounds) |ty, bound| { - check_bounds(cx, id_to_use, e.span, ty, bound) + check_bounds(cx, id_to_use, e.span, *ty, *bound) } } @@ -377,7 +377,7 @@ fn check_ty(aty: @ty, cx: ctx, v: visit::vt) { let did = ast_util::def_id_of_def(cx.tcx.def_map.get(id)); let bounds = ty::lookup_item_type(cx.tcx, did).bounds; do vec::iter2(*ts, *bounds) |ty, bound| { - check_bounds(cx, aty.id, aty.span, ty, bound) + check_bounds(cx, aty.id, aty.span, *ty, *bound) } } } diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index ce998378fe5..689f69f1ad0 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -955,7 +955,7 @@ impl Liveness { fn propagate_through_block(blk: blk, succ: LiveNode) -> LiveNode { let succ = self.propagate_through_opt_expr(blk.node.expr, succ); do blk.node.stmts.foldr(succ) |stmt, succ| { - self.propagate_through_stmt(stmt, succ) + self.propagate_through_stmt(*stmt, succ) } } @@ -975,7 +975,7 @@ impl Liveness { match decl.node { decl_local(locals) => { do locals.foldr(succ) |local, succ| { - self.propagate_through_local(local, succ) + self.propagate_through_local(*local, succ) } } decl_item(_) => { @@ -1007,7 +1007,7 @@ impl Liveness { fn propagate_through_exprs(exprs: ~[@expr], succ: LiveNode) -> LiveNode { do exprs.foldr(succ) |expr, succ| { - self.propagate_through_expr(expr, succ) + self.propagate_through_expr(*expr, succ) } } @@ -1575,7 +1575,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) { match ty::resolved_mode(self.tcx, arg_ty.mode) { by_val | by_copy | by_ref | by_mutbl_ref => {} by_move => { - self.check_move_from_expr(arg_expr, vt); + self.check_move_from_expr(*arg_expr, vt); } } } diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs index 03efd67a9d5..fc66b5dc7a1 100644 --- a/src/rustc/middle/resolve.rs +++ b/src/rustc/middle/resolve.rs @@ -1560,7 +1560,7 @@ impl Resolver { path_entry.def_like); let mut pieces = split_str(path_entry.path_string, ~"::"); - let final_ident_str = pop(pieces); + let final_ident_str = pieces.pop(); let final_ident = self.session.ident_of(final_ident_str); // Find the module we need, creating modules along the way if we diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs index 165ca8e2fc4..6450e48486c 100644 --- a/src/rustc/middle/trans/alt.rs +++ b/src/rustc/middle/trans/alt.rs @@ -581,7 +581,7 @@ fn collect_record_or_struct_fields(m: &[@Match], col: uint) -> ~[ast::ident] { fn extend(idents: &mut ~[ast::ident], field_pats: &[ast::field_pat]) { for field_pats.each |field_pat| { let field_ident = field_pat.ident; - if !vec::any(*idents, |x| x == field_ident) { + if !vec::any(*idents, |x| *x == field_ident) { idents.push(field_ident); } } diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index 7c70d83bd76..70231357003 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -57,7 +57,7 @@ struct icx_popper { ccx: @crate_ctxt, drop { if self.ccx.sess.count_llvm_insns() { - vec::pop(*(self.ccx.stats.llvm_insn_ctxt)); + self.ccx.stats.llvm_insn_ctxt.pop(); } } } diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs index e75d4db897f..907146be4fd 100644 --- a/src/rustc/middle/trans/common.rs +++ b/src/rustc/middle/trans/common.rs @@ -402,7 +402,7 @@ fn revoke_clean(cx: block, val: ValueRef) { do in_scope_cx(cx) |info| { let cleanup_pos = vec::position( info.cleanups, - |cu| match cu { + |cu| match *cu { clean_temp(v, _, _) if v == val => true, _ => false }); diff --git a/src/rustc/middle/trans/controlflow.rs b/src/rustc/middle/trans/controlflow.rs index 5d8b0fbbbe1..68ebf5fa189 100644 --- a/src/rustc/middle/trans/controlflow.rs +++ b/src/rustc/middle/trans/controlflow.rs @@ -158,7 +158,7 @@ fn trans_log(log_ex: @ast::expr, let modpath = vec::append( ~[path_mod(ccx.sess.ident_of(ccx.link_meta.name))], vec::filter(bcx.fcx.path, |e| - match e { path_mod(_) => true, _ => false } + match *e { path_mod(_) => true, _ => false } )); let modname = path_str(ccx.sess, modpath); diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index f1077912fec..74dadd2cab4 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -92,7 +92,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { Double => 8, Struct => { do vec::foldl(0, struct_tys(ty)) |a, t| { - uint::max(a, ty_align(t)) + uint::max(a, ty_align(*t)) } } Array => { @@ -113,7 +113,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { Double => 8, Struct => { do vec::foldl(0, struct_tys(ty)) |s, t| { - s + ty_size(t) + s + ty_size(*t) } } Array => { diff --git a/src/rustc/middle/trans/monomorphize.rs b/src/rustc/middle/trans/monomorphize.rs index bbcacec052e..cd8cffa297a 100644 --- a/src/rustc/middle/trans/monomorphize.rs +++ b/src/rustc/middle/trans/monomorphize.rs @@ -33,7 +33,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, let param_uses = type_use::type_uses_for(ccx, fn_id, substs.len()); let hash_id = make_mono_id(ccx, fn_id, substs, vtables, Some(param_uses)); if vec::any(hash_id.params, - |p| match p { mono_precise(_, _) => false, _ => true }) { + |p| match *p { mono_precise(_, _) => false, _ => true }) { must_cast = true; } @@ -243,7 +243,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t], let mut i = 0u; vec::map2(*bounds, substs, |bounds, subst| { let mut v = ~[]; - for vec::each(*bounds) |bound| { + for bounds.each |bound| { match *bound { ty::bound_trait(_) => { v.push(meth::vtable_id(ccx, vts[i])); @@ -252,7 +252,7 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t], _ => () } } - (subst, if v.len() > 0u { Some(v) } else { None }) + (*subst, if v.len() > 0u { Some(v) } else { None }) }) } None => { @@ -262,12 +262,12 @@ fn make_mono_id(ccx: @crate_ctxt, item: ast::def_id, substs: ~[ty::t], let param_ids = match param_uses { Some(uses) => { vec::map2(precise_param_ids, uses, |id, uses| { - match id { + match *id { (a, b@Some(_)) => mono_precise(a, b), (subst, None) => { - if uses == 0u { + if *uses == 0u { mono_any - } else if uses == type_use::use_repr && + } else if *uses == type_use::use_repr && !ty::type_needs_drop(ccx.tcx, subst) { let llty = type_of::type_of(ccx, subst); diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index b29f40748ed..f0d67b92339 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -206,7 +206,7 @@ fn mark_for_expr(cx: ctx, e: @expr) { let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get(e.id)); vec::iter2(type_uses_for(cx.ccx, id, ts.len()), *ts, |uses, subst| { - type_needs(cx, uses, subst) + type_needs(cx, *uses, *subst) }) } } @@ -239,7 +239,7 @@ fn mark_for_expr(cx: ctx, e: @expr) { typeck::method_static(did) => { do cx.ccx.tcx.node_type_substs.find(e.id).iter |ts| { do vec::iter2(type_uses_for(cx.ccx, did, ts.len()), *ts) - |uses, subst| { type_needs(cx, uses, subst)} + |uses, subst| { type_needs(cx, *uses, *subst)} } } typeck::method_param({param_num: param, _}) => { diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index 63720eaad2e..397a1cd6aa1 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -2238,7 +2238,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { false } - ty_class(did, _) if vec::contains(*seen, did) => { + ty_class(ref did, _) if vec::contains(*seen, did) => { false } @@ -2246,15 +2246,15 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { seen.push(did); let r = vec::any(class_items_as_fields(cx, did, substs), |f| type_requires(cx, seen, r_ty, f.mt.ty)); - vec::pop(*seen); + seen.pop(); r } ty_tup(ts) => { - vec::any(ts, |t| type_requires(cx, seen, r_ty, t)) + vec::any(ts, |t| type_requires(cx, seen, r_ty, *t)) } - ty_enum(did, _) if vec::contains(*seen, did) => { + ty_enum(ref did, _) if vec::contains(*seen, did) => { false } @@ -2263,11 +2263,11 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool { let vs = enum_variants(cx, did); let r = vec::len(*vs) > 0u && vec::all(*vs, |variant| { vec::any(variant.args, |aty| { - let sty = subst(cx, substs, aty); + let sty = subst(cx, substs, *aty); type_requires(cx, seen, r_ty, sty) }) }); - vec::pop(*seen); + seen.pop(); r } }; @@ -3063,7 +3063,7 @@ fn occurs_check(tcx: ctxt, sp: span, vid: TyVid, rt: t) { if !type_needs_infer(rt) { return; } // Occurs check! - if vec::contains(vars_in_type(rt), vid) { + if vec::contains(vars_in_type(rt), &vid) { // Maybe this should be span_err -- however, there's an // assertion later on that the type doesn't contain // variables, so in this case we have to be sure to die. diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index e1a0e8bc9ed..a1cfb91ebdc 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -309,7 +309,7 @@ fn check_fn(ccx: @crate_ctxt, fcx.write_ty(info.self_id, info.self_ty); } do vec::iter2(decl.inputs, arg_tys) |input, arg| { - fcx.write_ty(input.id, arg); + fcx.write_ty(input.id, *arg); } // If we don't have any enclosing function scope, it is time to @@ -352,7 +352,7 @@ fn check_fn(ccx: @crate_ctxt, // Add formal parameters. do vec::iter2(arg_tys, decl.inputs) |arg_ty, input| { - assign(input.ty.span, input.id, Some(arg_ty)); + assign(input.ty.span, input.id, Some(*arg_ty)); debug!("Argument %s is assigned to %s", tcx.sess.str_of(input.ident), fcx.inh.locals.get(input.id).to_str()); @@ -807,7 +807,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) { _ => () } } - ty::ty_enum(did, _) => { + ty::ty_enum(ref did, _) => { // Watch out for a type like `enum t = @t`. Such a // type would otherwise infinitely auto-deref. Only // autoderef loops during typeck (basically, this one @@ -818,7 +818,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) { if vec::contains(enum_dids, did) { return (t1, autoderefs); } - enum_dids.push(did); + enum_dids.push(*did); } _ => { /*ok*/ } } @@ -2294,7 +2294,7 @@ fn check_enum_variants(ccx: @crate_ctxt, } _ => () } - if vec::contains(*disr_vals, *disr_val) { + if vec::contains(*disr_vals, &*disr_val) { ccx.tcx.sess.span_err(v.span, ~"discriminator value already exists"); } diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs index 3b299caf872..ace045ec4a7 100644 --- a/src/rustc/middle/typeck/check/alt.rs +++ b/src/rustc/middle/typeck/check/alt.rs @@ -165,7 +165,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path, do subpats.iter() |pats| { do vec::iter2(*pats, arg_types) |subpat, arg_ty| { - check_pat(pcx, subpat, arg_ty); + check_pat(pcx, *subpat, *arg_ty); } }; } else if subpats_len > 0u { diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs index 38ca571dae5..06f466f74d5 100644 --- a/src/rustc/middle/typeck/check/vtable.rs +++ b/src/rustc/middle/typeck/check/vtable.rs @@ -23,7 +23,7 @@ use util::common::indenter; fn has_trait_bounds(tps: ~[ty::param_bounds]) -> bool { vec::any(tps, |bs| { - vec::any(*bs, |b| { + bs.any(|b| { match b { ty::bound_trait(_) => true, _ => false } }) }) @@ -393,7 +393,7 @@ fn connect_trait_tps(fcx: @fn_ctxt, expr: @ast::expr, impl_tys: ~[ty::t], match ty::get(trait_ty).sty { ty::ty_trait(_, substs, _) => { vec::iter2(substs.tps, trait_tys, - |a, b| demand::suptype(fcx, expr.span, a, b)); + |a, b| demand::suptype(fcx, expr.span, *a, *b)); } _ => tcx.sess.impossible_case(expr.span, "connect_trait_tps: \ don't know how to handle a non-trait ty") diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index 630ac8c13a1..18e29981af3 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -725,7 +725,7 @@ fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) fn compute_bounds(ccx: @crate_ctxt, ast_bounds: @~[ast::ty_param_bound]) -> ty::param_bounds { @do vec::flat_map(*ast_bounds) |b| { - match b { + match *b { ast::bound_send => ~[ty::bound_send], ast::bound_copy => ~[ty::bound_copy], ast::bound_const => ~[ty::bound_const], diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index a0bb828e412..e5aa0debfe1 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -507,7 +507,7 @@ fn rollback_to( vb: &vals_and_bindings, len: uint) { while vb.bindings.len() != len { - let (vid, old_v) = vec::pop(vb.bindings); + let (vid, old_v) = vb.bindings.pop(); vb.vals.insert(vid.to_uint(), old_v); } } diff --git a/src/rustc/middle/typeck/infer/region_var_bindings.rs b/src/rustc/middle/typeck/infer/region_var_bindings.rs index 8eabb2c0787..c86850e19d2 100644 --- a/src/rustc/middle/typeck/infer/region_var_bindings.rs +++ b/src/rustc/middle/typeck/infer/region_var_bindings.rs @@ -1192,7 +1192,7 @@ impl RegionVarBindings { set.insert(*orig_node_idx, ()); let mut result = ~[]; while !vec::is_empty(stack) { - let node_idx = vec::pop(stack); + let node_idx = stack.pop(); for self.each_edge(graph, node_idx, dir) |edge| { match edge.constraint { ConstrainVarSubVar(from_vid, to_vid) => { diff --git a/src/rustc/middle/typeck/infer/resolve.rs b/src/rustc/middle/typeck/infer/resolve.rs index a366a2ef1c7..2a851a5f7bb 100644 --- a/src/rustc/middle/typeck/infer/resolve.rs +++ b/src/rustc/middle/typeck/infer/resolve.rs @@ -170,7 +170,7 @@ impl resolve_state { } fn resolve_ty_var(vid: TyVid) -> ty::t { - if vec::contains(self.v_seen, vid) { + if vec::contains(self.v_seen, &vid) { self.err = Some(cyclic_ty(vid)); return ty::mk_var(self.infcx.tcx, vid); } else { @@ -197,7 +197,7 @@ impl resolve_state { ty::mk_var(tcx, vid) } }; - vec::pop(self.v_seen); + self.v_seen.pop(); return t1; } } diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs index b3ba7f14109..71a32dc112f 100644 --- a/src/rustdoc/attr_pass.rs +++ b/src/rustdoc/attr_pass.rs @@ -236,7 +236,7 @@ fn merge_method_attrs( { desc: desc, - .. doc + ..*doc } } } diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs index c57e712c020..d601d6d92d1 100644 --- a/src/rustdoc/config.rs +++ b/src/rustdoc/config.rs @@ -228,8 +228,8 @@ fn maybe_find_pandoc( }; let pandoc = do vec::find(possible_pandocs) |pandoc| { - let output = program_output(pandoc, ~[~"--version"]); - debug!("testing pandoc cmd %s: %?", pandoc, output); + let output = program_output(*pandoc, ~[~"--version"]); + debug!("testing pandoc cmd %s: %?", *pandoc, output); output.status == 0 }; diff --git a/src/rustdoc/desc_to_brief_pass.rs b/src/rustdoc/desc_to_brief_pass.rs index b517c2f2409..3fcce7db6c4 100644 --- a/src/rustdoc/desc_to_brief_pass.rs +++ b/src/rustdoc/desc_to_brief_pass.rs @@ -165,7 +165,7 @@ fn paragraphs(s: ~str) -> ~[~str] { let paras = do vec::foldl(~[], lines) |paras, line| { let mut res = paras; - if str::is_whitespace(line) { + if str::is_whitespace(*line) { whitespace_lines += 1; } else { if whitespace_lines > 0 { @@ -178,9 +178,9 @@ fn paragraphs(s: ~str) -> ~[~str] { whitespace_lines = 0; accum = if str::is_empty(accum) { - line + *line } else { - accum + ~"\n" + line + accum + ~"\n" + *line } } diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs index 82bddf11d16..0764d9e2432 100644 --- a/src/rustdoc/doc.rs +++ b/src/rustdoc/doc.rs @@ -378,7 +378,7 @@ impl IndexEntry : cmp::Eq { impl Doc { fn CrateDoc() -> CrateDoc { option::get(&vec::foldl(None, self.pages, |_m, page| { - match page { + match *page { doc::CratePage(doc) => Some(doc), _ => None } @@ -395,7 +395,7 @@ impl ModDoc { fn mods() -> ~[ModDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { ModTag(ModDoc) => Some(ModDoc), _ => None } @@ -404,7 +404,7 @@ impl ModDoc { fn nmods() -> ~[NmodDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { NmodTag(nModDoc) => Some(nModDoc), _ => None } @@ -413,7 +413,7 @@ impl ModDoc { fn fns() -> ~[FnDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { FnTag(FnDoc) => Some(FnDoc), _ => None } @@ -422,7 +422,7 @@ impl ModDoc { fn consts() -> ~[ConstDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { ConstTag(ConstDoc) => Some(ConstDoc), _ => None } @@ -431,7 +431,7 @@ impl ModDoc { fn enums() -> ~[EnumDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { EnumTag(EnumDoc) => Some(EnumDoc), _ => None } @@ -440,7 +440,7 @@ impl ModDoc { fn traits() -> ~[TraitDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { TraitTag(TraitDoc) => Some(TraitDoc), _ => None } @@ -449,7 +449,7 @@ impl ModDoc { fn impls() -> ~[ImplDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { ImplTag(ImplDoc) => Some(ImplDoc), _ => None } @@ -458,7 +458,7 @@ impl ModDoc { fn types() -> ~[TyDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { TyTag(TyDoc) => Some(TyDoc), _ => None } @@ -467,7 +467,7 @@ impl ModDoc { fn structs() -> ~[StructDoc] { do vec::filter_map(self.items) |itemtag| { - match itemtag { + match *itemtag { StructTag(StructDoc) => Some(StructDoc), _ => None } @@ -490,7 +490,7 @@ impl ~[Page]: PageUtils { fn mods() -> ~[ModDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(ModTag(ModDoc)) => Some(ModDoc), _ => None } @@ -499,7 +499,7 @@ impl ~[Page]: PageUtils { fn nmods() -> ~[NmodDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(NmodTag(nModDoc)) => Some(nModDoc), _ => None } @@ -508,7 +508,7 @@ impl ~[Page]: PageUtils { fn fns() -> ~[FnDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(FnTag(FnDoc)) => Some(FnDoc), _ => None } @@ -517,7 +517,7 @@ impl ~[Page]: PageUtils { fn consts() -> ~[ConstDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(ConstTag(ConstDoc)) => Some(ConstDoc), _ => None } @@ -526,7 +526,7 @@ impl ~[Page]: PageUtils { fn enums() -> ~[EnumDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(EnumTag(EnumDoc)) => Some(EnumDoc), _ => None } @@ -535,7 +535,7 @@ impl ~[Page]: PageUtils { fn traits() -> ~[TraitDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(TraitTag(TraitDoc)) => Some(TraitDoc), _ => None } @@ -544,7 +544,7 @@ impl ~[Page]: PageUtils { fn impls() -> ~[ImplDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(ImplTag(ImplDoc)) => Some(ImplDoc), _ => None } @@ -553,7 +553,7 @@ impl ~[Page]: PageUtils { fn types() -> ~[TyDoc] { do vec::filter_map(self) |page| { - match page { + match *page { ItemPage(TyTag(TyDoc)) => Some(TyDoc), _ => None } diff --git a/src/rustdoc/page_pass.rs b/src/rustdoc/page_pass.rs index 8710792f0e4..ad3f679a97c 100644 --- a/src/rustdoc/page_pass.rs +++ b/src/rustdoc/page_pass.rs @@ -105,7 +105,7 @@ fn fold_mod( fn strip_mod(doc: doc::ModDoc) -> doc::ModDoc { doc::ModDoc_({ items: do vec::filter(doc.items) |item| { - match item { + match *item { doc::ModTag(_) => false, doc::NmodTag(_) => false, _ => true diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs index 96ed269a7e9..f6a241fdac8 100644 --- a/src/rustdoc/path_pass.rs +++ b/src/rustdoc/path_pass.rs @@ -45,7 +45,7 @@ fn fold_mod(fold: fold::Fold, doc: doc::ModDoc) -> doc::ModDoc { if !is_topmod { fold.ctxt.path.push(doc.name()); } let doc = fold::default_any_fold_mod(fold, doc); - if !is_topmod { vec::pop(fold.ctxt.path); } + if !is_topmod { fold.ctxt.path.pop(); } doc::ModDoc_({ item: fold.fold_item(fold, doc.item), @@ -56,7 +56,7 @@ fn fold_mod(fold: fold::Fold, doc: doc::ModDoc) -> doc::ModDoc { fn fold_nmod(fold: fold::Fold, doc: doc::NmodDoc) -> doc::NmodDoc { fold.ctxt.path.push(doc.name()); let doc = fold::default_seq_fold_nmod(fold, doc); - vec::pop(fold.ctxt.path); + fold.ctxt.path.pop(); { item: fold.fold_item(fold, doc.item), diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs index 62db53b7600..5e2d141318a 100644 --- a/src/rustdoc/tystr_pass.rs +++ b/src/rustdoc/tystr_pass.rs @@ -177,7 +177,7 @@ fn get_method_sig( node: ast::item_trait(_, _, methods), _ }, _) => { match vec::find(methods, |method| { - match method { + match *method { ast::required(ty_m) => to_str(ty_m.ident) == method_name, ast::provided(m) => to_str(m.ident) == method_name, } diff --git a/src/rustdoc/unindent_pass.rs b/src/rustdoc/unindent_pass.rs index 42c9e80ab7b..aa31892d466 100644 --- a/src/rustdoc/unindent_pass.rs +++ b/src/rustdoc/unindent_pass.rs @@ -29,7 +29,7 @@ fn unindent(s: ~str) -> ~str { let ignore_previous_indents = saw_first_line && !saw_second_line && - !str::is_whitespace(line); + !str::is_whitespace(*line); let min_indent = if ignore_previous_indents { uint::max_value @@ -41,12 +41,12 @@ fn unindent(s: ~str) -> ~str { saw_second_line = true; } - if str::is_whitespace(line) { + if str::is_whitespace(*line) { min_indent } else { saw_first_line = true; let mut spaces = 0; - do str::all(line) |char| { + do str::all(*line) |char| { // Only comparing against space because I wouldn't // know what to do with mixed whitespace chars if char == ' ' { diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 9454ef7aec7..cf44d478356 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -47,7 +47,7 @@ fn shift_push() { let mut v2 = ~[]; while v1.len() > 0 { - v2.push(vec::shift(v1)); + v2.push(v1.shift()); } } diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index ef2fa8dfa9e..10b38f2572c 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -97,7 +97,7 @@ fn gen_search_keys(graph: graph, n: uint) -> ~[node_id] { let k = r.gen_uint_range(0u, graph.len()); if graph[k].len() > 0u && vec::any(graph[k], |i| { - i != k as node_id + *i != k as node_id }) { map::set_add(keys, k as node_id); } @@ -160,8 +160,8 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result { } }; - fn is_gray(c: color) -> bool { - match c { + fn is_gray(c: &color) -> bool { + match *c { gray(_) => { true } _ => { false } } @@ -183,7 +183,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result { let mut color = white; do neighbors.each() |k| { - if is_gray(colors[*k]) { + if is_gray(&colors[*k]) { color = gray(*k); false } @@ -314,7 +314,7 @@ fn validate(edges: ~[(node_id, node_id)], } else { while parent != root { - if vec::contains(path, parent) { + if vec::contains(path, &parent) { status = false; } @@ -336,8 +336,8 @@ fn validate(edges: ~[(node_id, node_id)], log(info, ~"Verifying tree edges..."); let status = do tree.alli() |k, parent| { - if parent != root && parent != -1i64 { - level[parent] == level[k] - 1 + if *parent != root && *parent != -1i64 { + level[*parent] == level[k] - 1 } else { true diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index 2931cab248f..ec144b78a10 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -27,7 +27,7 @@ fn recv(p: &pipe) -> uint { while vec::is_empty(*state) { cond.wait(); } - vec::pop(*state) + state.pop() } } diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index 525cf8f1c50..1b857b6caeb 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -27,7 +27,7 @@ fn recv(p: &pipe) -> uint { while vec::is_empty(*state) { cond.wait(); } - vec::pop(*state) + state.pop() } } diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs index b8e34aefd6f..15154ab5a4e 100644 --- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs +++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs @@ -2,7 +2,7 @@ fn compute1() -> float { let v = ~[0f, 1f, 2f, 3f]; - do vec::foldl(0f, v) |x, y| { x + y } - 10f + do vec::foldl(0f, v) |x, y| { x + *y } - 10f //~^ ERROR mismatched types: expected `()` } diff --git a/src/test/compile-fail/regions-escape-loop-via-vec.rs b/src/test/compile-fail/regions-escape-loop-via-vec.rs index 638f14f8794..276862ce106 100644 --- a/src/test/compile-fail/regions-escape-loop-via-vec.rs +++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs @@ -7,7 +7,7 @@ fn broken() -> int { y += ~[&mut z]; //~ ERROR illegal borrow x += 1; } - vec::foldl(0, y, |v, p| v + *p ) + vec::foldl(0, y, |v, p| v + **p ) } fn main() { } \ No newline at end of file diff --git a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs index 53f158471e8..bab28a06934 100644 --- a/src/test/run-pass/block-arg-can-be-followed-by-binop.rs +++ b/src/test/run-pass/block-arg-can-be-followed-by-binop.rs @@ -2,7 +2,7 @@ fn main() { let v = ~[-1f, 0f, 1f, 2f, 3f]; // Trailing expressions don't require parentheses: - let y = do vec::foldl(0f, v) |x, y| { x + y } + 10f; + let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; assert y == 15f; } diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs index 14b05b29dc3..1121cc4dd2f 100644 --- a/src/test/run-pass/block-arg-in-parentheses.rs +++ b/src/test/run-pass/block-arg-in-parentheses.rs @@ -1,20 +1,20 @@ fn w_semi(v: ~[int]) -> int { // the semicolon causes compiler not to // complain about the ignored return value: - do vec::foldl(0, v) |x,y| { x+y }; + do vec::foldl(0, v) |x,y| { x+*y }; -10 } fn w_paren1(v: ~[int]) -> int { - (do vec::foldl(0, v) |x,y| { x+y }) - 10 + (do vec::foldl(0, v) |x,y| { x+*y }) - 10 } fn w_paren2(v: ~[int]) -> int { - (do vec::foldl(0, v) |x,y| { x+y} - 10) + (do vec::foldl(0, v) |x,y| { x+*y} - 10) } fn w_ret(v: ~[int]) -> int { - return do vec::foldl(0, v) |x,y| { x+y } - 10; + return do vec::foldl(0, v) |x,y| { x+*y } - 10; } fn main() { diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs index 5953e0b85fb..0f77a0e0816 100644 --- a/src/test/run-pass/block-arg.rs +++ b/src/test/run-pass/block-arg.rs @@ -8,28 +8,28 @@ fn main() { } // Usable at all: - let mut any_negative = do vec::any(v) |e| { float::is_negative(e) }; + let mut any_negative = do vec::any(v) |e| { float::is_negative(*e) }; assert any_negative; // Higher precedence than assignments: - any_negative = do vec::any(v) |e| { float::is_negative(e) }; + any_negative = do vec::any(v) |e| { float::is_negative(*e) }; assert any_negative; // Higher precedence than unary operations: let abs_v = do vec::map(v) |e| { float::abs(*e) }; - assert do vec::all(abs_v) |e| { float::is_nonnegative(e) }; - assert !do vec::any(abs_v) |e| { float::is_negative(e) }; + assert do vec::all(abs_v) |e| { float::is_nonnegative(*e) }; + assert !do vec::any(abs_v) |e| { float::is_negative(*e) }; // Usable in funny statement-like forms: - if !do vec::any(v) |e| { float::is_positive(e) } { + if !do vec::any(v) |e| { float::is_positive(*e) } { assert false; } - match do vec::all(v) |e| { float::is_negative(e) } { + match do vec::all(v) |e| { float::is_negative(*e) } { true => { fail ~"incorrect answer."; } false => { } } match 3 { - _ if do vec::any(v) |e| { float::is_negative(e) } => { + _ if do vec::any(v) |e| { float::is_negative(*e) } => { } _ => { fail ~"wrong answer."; @@ -38,15 +38,15 @@ fn main() { // Lower precedence than binary operations: - let w = do vec::foldl(0f, v) |x, y| { x + y } + 10f; - let y = do vec::foldl(0f, v) |x, y| { x + y } + 10f; - let z = 10f + do vec::foldl(0f, v) |x, y| { x + y }; + let w = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; + let y = do vec::foldl(0f, v) |x, y| { x + *y } + 10f; + let z = 10f + do vec::foldl(0f, v) |x, y| { x + *y }; assert w == y; assert y == z; // In the tail of a block let w = - if true { do vec::any(abs_v) |e| { float::is_nonnegative(e) } } + if true { do vec::any(abs_v) |e| { float::is_nonnegative(*e) } } else { false }; assert w; } diff --git a/src/test/run-pass/block-vec-map2.rs b/src/test/run-pass/block-vec-map2.rs index 332afc65f72..d270800de11 100644 --- a/src/test/run-pass/block-vec-map2.rs +++ b/src/test/run-pass/block-vec-map2.rs @@ -4,7 +4,7 @@ fn main() { let v = vec::map2(~[1, 2, 3, 4, 5], ~[true, false, false, true, true], - |i, b| if b { -i } else { i } ); + |i, b| if *b { -(*i) } else { *i } ); log(error, v); assert (v == ~[-1, 2, 3, -4, -5]); } diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs index 9013842ba8b..4e7e978cf55 100644 --- a/src/test/run-pass/ret-break-cont-in-block.rs +++ b/src/test/run-pass/ret-break-cont-in-block.rs @@ -43,10 +43,10 @@ fn ret_deep() -> ~str { fn main() { let mut last = 0; for vec::all(~[1, 2, 3, 4, 5, 6, 7]) |e| { - last = e; - if e == 5 { break; } - if e % 2 == 1 { loop; } - assert e % 2 == 0; + last = *e; + if *e == 5 { break; } + if *e % 2 == 1 { loop; } + assert *e % 2 == 0; }; assert last == 5; -- cgit 1.4.1-3-g733a5 From 8cc61c816a0f08535f6300af4a5eaf30b8094c57 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 1 Oct 2012 14:01:42 -0700 Subject: De-export std::{rope,smallintmap}. Part of #3583. --- src/libstd/rope.rs | 139 ++++++++++++++++++++++------------------------ src/libstd/smallintmap.rs | 14 ++--- src/libstd/std.rc | 2 - 3 files changed, 74 insertions(+), 81 deletions(-) (limited to 'src/libstd/smallintmap.rs') diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 3f10fdb2b1d..47539b2dab6 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -26,14 +26,14 @@ #[forbid(deprecated_mode)]; /// The type of ropes. -type Rope = node::Root; +pub type Rope = node::Root; /* Section: Creating a rope */ /// Create an empty rope -fn empty() -> Rope { +pub fn empty() -> Rope { return node::Empty; } @@ -54,7 +54,7 @@ fn empty() -> Rope { * * this operation does not copy the string; * * the function runs in linear time. */ -fn of_str(str: @~str) -> Rope { +pub fn of_str(str: @~str) -> Rope { return of_substr(str, 0u, str::len(*str)); } @@ -80,7 +80,7 @@ fn of_str(str: @~str) -> Rope { * * this function does _not_ check the validity of the substring; * * this function fails if `byte_offset` or `byte_len` do not match `str`. */ -fn of_substr(str: @~str, byte_offset: uint, byte_len: uint) -> Rope { +pub fn of_substr(str: @~str, byte_offset: uint, byte_len: uint) -> Rope { if byte_len == 0u { return node::Empty; } if byte_offset + byte_len > str::len(*str) { fail; } return node::Content(node::of_substr(str, byte_offset, byte_len)); @@ -97,7 +97,7 @@ Section: Adding things to a rope * * * this function executes in near-constant time */ -fn append_char(rope: Rope, char: char) -> Rope { +pub fn append_char(rope: Rope, char: char) -> Rope { return append_str(rope, @str::from_chars(~[char])); } @@ -108,7 +108,7 @@ fn append_char(rope: Rope, char: char) -> Rope { * * * this function executes in near-linear time */ -fn append_str(rope: Rope, str: @~str) -> Rope { +pub fn append_str(rope: Rope, str: @~str) -> Rope { return append_rope(rope, of_str(str)) } @@ -118,7 +118,7 @@ fn append_str(rope: Rope, str: @~str) -> Rope { * # Performance note * * this function executes in near-constant time */ -fn prepend_char(rope: Rope, char: char) -> Rope { +pub fn prepend_char(rope: Rope, char: char) -> Rope { return prepend_str(rope, @str::from_chars(~[char])); } @@ -128,12 +128,12 @@ fn prepend_char(rope: Rope, char: char) -> Rope { * # Performance note * * this function executes in near-linear time */ -fn prepend_str(rope: Rope, str: @~str) -> Rope { +pub fn prepend_str(rope: Rope, str: @~str) -> Rope { return append_rope(of_str(str), rope) } /// Concatenate two ropes -fn append_rope(left: Rope, right: Rope) -> Rope { +pub fn append_rope(left: Rope, right: Rope) -> Rope { match (left) { node::Empty => return right, node::Content(left_content) => { @@ -154,7 +154,7 @@ fn append_rope(left: Rope, right: Rope) -> Rope { * rope remains balanced. However, this function does not take any further * measure to ensure that the result is balanced. */ -fn concat(v: ~[Rope]) -> Rope { +pub fn concat(v: ~[Rope]) -> Rope { //Copy `v` into a mut vector let mut len = vec::len(v); if len == 0u { return node::Empty; } @@ -197,7 +197,7 @@ Section: Keeping ropes healthy * If you perform numerous rope concatenations, it is generally a good idea * to rebalance your rope at some point, before using it for other purposes. */ -fn bal(rope:Rope) -> Rope { +pub fn bal(rope:Rope) -> Rope { match (rope) { node::Empty => return rope, node::Content(x) => match (node::bal(x)) { @@ -225,7 +225,7 @@ Section: Transforming ropes * * this function fails if char_offset/char_len do not represent * valid positions in rope */ -fn sub_chars(rope: Rope, char_offset: uint, char_len: uint) -> Rope { +pub fn sub_chars(rope: Rope, char_offset: uint, char_len: uint) -> Rope { if char_len == 0u { return node::Empty; } match (rope) { node::Empty => fail, @@ -250,7 +250,7 @@ fn sub_chars(rope: Rope, char_offset: uint, char_len: uint) -> Rope { * * this function fails if byte_offset/byte_len do not represent * valid positions in rope */ -fn sub_bytes(rope: Rope, byte_offset: uint, byte_len: uint) -> Rope { +pub fn sub_bytes(rope: Rope, byte_offset: uint, byte_len: uint) -> Rope { if byte_len == 0u { return node::Empty; } match (rope) { node::Empty => fail, @@ -276,7 +276,7 @@ Section: Comparing ropes * A negative value if `left < right`, 0 if eq(left, right) or a positive * value if `left > right` */ -fn cmp(left: Rope, right: Rope) -> int { +pub fn cmp(left: Rope, right: Rope) -> int { match ((left, right)) { (node::Empty, node::Empty) => return 0, (node::Empty, _) => return -1, @@ -291,7 +291,7 @@ fn cmp(left: Rope, right: Rope) -> int { * Returns `true` if both ropes have the same content (regardless of * their structure), `false` otherwise */ -fn eq(left: Rope, right: Rope) -> bool { +pub fn eq(left: Rope, right: Rope) -> bool { return cmp(left, right) == 0; } @@ -306,7 +306,7 @@ fn eq(left: Rope, right: Rope) -> bool { * `true` if `left <= right` in lexicographical order (regardless of their * structure), `false` otherwise */ -fn le(left: Rope, right: Rope) -> bool { +pub fn le(left: Rope, right: Rope) -> bool { return cmp(left, right) <= 0; } @@ -321,7 +321,7 @@ fn le(left: Rope, right: Rope) -> bool { * `true` if `left < right` in lexicographical order (regardless of their * structure), `false` otherwise */ -fn lt(left: Rope, right: Rope) -> bool { +pub fn lt(left: Rope, right: Rope) -> bool { return cmp(left, right) < 0; } @@ -336,7 +336,7 @@ fn lt(left: Rope, right: Rope) -> bool { * `true` if `left >= right` in lexicographical order (regardless of their * structure), `false` otherwise */ -fn ge(left: Rope, right: Rope) -> bool { +pub fn ge(left: Rope, right: Rope) -> bool { return cmp(left, right) >= 0; } @@ -351,7 +351,7 @@ fn ge(left: Rope, right: Rope) -> bool { * `true` if `left > right` in lexicographical order (regardless of their * structure), `false` otherwise */ -fn gt(left: Rope, right: Rope) -> bool { +pub fn gt(left: Rope, right: Rope) -> bool { return cmp(left, right) > 0; } @@ -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. */ -fn loop_chars(rope: Rope, it: fn(char) -> bool) -> bool { +pub fn loop_chars(rope: Rope, it: fn(char) -> bool) -> bool { match (rope) { node::Empty => return true, node::Content(x) => return node::loop_chars(x, it) @@ -393,7 +393,7 @@ fn loop_chars(rope: Rope, it: fn(char) -> bool) -> bool { * * rope - A rope to traverse. It may be empty * * it - A block to execute with each consecutive character of the rope. */ -fn iter_chars(rope: Rope, it: fn(char)) { +pub fn iter_chars(rope: Rope, it: fn(char)) { do loop_chars(rope) |x| { it(x); true @@ -422,17 +422,15 @@ fn iter_chars(rope: Rope, it: fn(char)) { * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ -fn loop_leaves(rope: Rope, it: fn(node::Leaf) -> bool) -> bool{ +pub fn loop_leaves(rope: Rope, it: fn(node::Leaf) -> bool) -> bool{ match (rope) { node::Empty => return true, node::Content(x) => return node::loop_leaves(x, it) } } -mod iterator { - #[legacy_exports]; - mod leaf { - #[legacy_exports]; +pub mod iterator { + pub mod leaf { fn start(rope: Rope) -> node::leaf_iterator::T { match (rope) { node::Empty => return node::leaf_iterator::empty(), @@ -443,8 +441,7 @@ mod iterator { return node::leaf_iterator::next(it); } } - mod char { - #[legacy_exports]; + pub mod char { fn start(rope: Rope) -> node::char_iterator::T { match (rope) { node::Empty => return node::char_iterator::empty(), @@ -472,7 +469,7 @@ mod iterator { * * Constant time. */ -fn height(rope: Rope) -> uint { +pub fn height(rope: Rope) -> uint { match (rope) { node::Empty => return 0u, node::Content(x) => return node::height(x) @@ -488,7 +485,7 @@ fn height(rope: Rope) -> uint { * * Constant time. */ -pure fn char_len(rope: Rope) -> uint { +pub pure fn char_len(rope: Rope) -> uint { match (rope) { node::Empty => return 0u, node::Content(x) => return node::char_len(x) @@ -502,7 +499,7 @@ pure fn char_len(rope: Rope) -> uint { * * Constant time. */ -pure fn byte_len(rope: Rope) -> uint { +pub pure fn byte_len(rope: Rope) -> uint { match (rope) { node::Empty => return 0u, node::Content(x) => return node::byte_len(x) @@ -525,7 +522,7 @@ pure fn byte_len(rope: Rope) -> uint { * This function executes in a time proportional to the height of the * rope + the (bounded) length of the largest leaf. */ -fn char_at(rope: Rope, pos: uint) -> char { +pub fn char_at(rope: Rope, pos: uint) -> char { match (rope) { node::Empty => fail, node::Content(x) => return node::char_at(x, pos) @@ -537,10 +534,9 @@ fn char_at(rope: Rope, pos: uint) -> char { Section: Implementation */ mod node { - #[legacy_exports]; /// Implementation of type `rope` - enum Root { + pub enum Root { /// An empty rope Empty, /// A non-empty rope @@ -564,7 +560,7 @@ mod node { * string can be shared between several ropes, e.g. for indexing * purposes. */ - type Leaf = { + pub type Leaf = { byte_offset: uint, byte_len: uint, char_len: uint, @@ -588,7 +584,7 @@ mod node { * * Used for rebalancing and to allocate stacks for traversals. */ - type Concat = { + pub type Concat = { //FIXME (#2744): Perhaps a `vec` instead of `left`/`right` left: @Node, right: @Node, @@ -597,7 +593,7 @@ mod node { height: uint }; - enum Node { + pub enum Node { /// A leaf consisting in a `str` Leaf(Leaf), /// The concatenation of two ropes @@ -609,14 +605,14 @@ mod node { * * This is not a strict value */ - const hint_max_leaf_char_len: uint = 256u; + pub const hint_max_leaf_char_len: uint = 256u; /** * The maximal height that _should_ be permitted in a tree. * * This is not a strict value */ - const hint_max_node_height: uint = 16u; + pub const hint_max_node_height: uint = 16u; /** * Adopt a string as a node. @@ -628,7 +624,7 @@ mod node { * Performance note: The complexity of this function is linear in * the length of `str`. */ - fn of_str(str: @~str) -> @Node { + pub fn of_str(str: @~str) -> @Node { return of_substr(str, 0u, str::len(*str)); } @@ -649,7 +645,7 @@ mod node { * Behavior is undefined if `byte_start` or `byte_len` do not represent * valid positions in `str` */ - fn of_substr(str: @~str, byte_start: uint, byte_len: uint) -> @Node { + pub fn of_substr(str: @~str, byte_start: uint, byte_len: uint) -> @Node { return of_substr_unsafer(str, byte_start, byte_len, str::count_chars(*str, byte_start, byte_len)); } @@ -675,8 +671,8 @@ mod node { * * Behavior is undefined if `char_len` does not accurately represent the * number of chars between byte_start and byte_start+byte_len */ - fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint, - char_len: uint) -> @Node { + pub fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint, + char_len: uint) -> @Node { assert(byte_start + byte_len <= str::len(*str)); let candidate = @Leaf({ byte_offset: byte_start, @@ -733,7 +729,7 @@ mod node { } } - pure fn byte_len(node: @Node) -> uint { + pub pure fn byte_len(node: @Node) -> uint { //FIXME (#2744): Could we do this without the pattern-matching? match (*node) { Leaf(y) => return y.byte_len, @@ -741,7 +737,7 @@ mod node { } } - pure fn char_len(node: @Node) -> uint { + pub pure fn char_len(node: @Node) -> uint { match (*node) { Leaf(y) => return y.char_len, Concat(ref y) => return y.char_len @@ -756,7 +752,7 @@ mod node { * * forest - The forest. This vector is progressively rewritten during * execution and should be discarded as meaningless afterwards. */ - fn tree_from_forest_destructive(forest: &[mut @Node]) -> @Node { + pub fn tree_from_forest_destructive(forest: &[mut @Node]) -> @Node { let mut i; let mut len = vec::len(forest); while len > 1u { @@ -800,7 +796,7 @@ mod node { return forest[0]; } - fn serialize_node(node: @Node) -> ~str unsafe { + pub fn serialize_node(node: @Node) -> ~str unsafe { let mut buf = vec::to_mut(vec::from_elem(byte_len(node), 0u8)); let mut offset = 0u;//Current position in the buffer let it = leaf_iterator::start(node); @@ -831,7 +827,7 @@ mod node { * * This function executes in linear time. */ - fn flatten(node: @Node) -> @Node unsafe { + pub fn flatten(node: @Node) -> @Node unsafe { match (*node) { Leaf(_) => return node, Concat(ref x) => { @@ -860,7 +856,7 @@ mod node { * * `option::some(x)` otherwise, in which case `x` has the same contents * as `node` bot lower height and/or fragmentation. */ - fn bal(node: @Node) -> Option<@Node> { + pub fn bal(node: @Node) -> Option<@Node> { if height(node) < hint_max_node_height { return option::None; } //1. Gather all leaves as a forest let mut forest = ~[]; @@ -896,7 +892,8 @@ mod node { * This function fails if `byte_offset` or `byte_len` do not represent * valid positions in `node`. */ - fn sub_bytes(node: @Node, byte_offset: uint, byte_len: uint) -> @Node { + pub fn sub_bytes(node: @Node, byte_offset: uint, + byte_len: uint) -> @Node { let mut node = node; let mut byte_offset = byte_offset; loop { @@ -957,7 +954,8 @@ mod node { * This function fails if `char_offset` or `char_len` do not represent * valid positions in `node`. */ - fn sub_chars(node: @Node, char_offset: uint, char_len: uint) -> @Node { + pub fn sub_chars(node: @Node, char_offset: uint, + char_len: uint) -> @Node { let mut node = node; let mut char_offset = char_offset; loop { @@ -1002,7 +1000,7 @@ mod node { }; } - fn concat2(left: @Node, right: @Node) -> @Node { + pub fn concat2(left: @Node, right: @Node) -> @Node { return @Concat({left : left, right : right, char_len: char_len(left) + char_len(right), @@ -1011,14 +1009,14 @@ mod node { }) } - fn height(node: @Node) -> uint { + pub fn height(node: @Node) -> uint { match (*node) { Leaf(_) => return 0u, Concat(ref x) => return x.height } } - fn cmp(a: @Node, b: @Node) -> int { + pub fn cmp(a: @Node, b: @Node) -> int { let ita = char_iterator::start(a); let itb = char_iterator::start(b); let mut result = 0; @@ -1039,7 +1037,7 @@ mod node { return result; } - fn loop_chars(node: @Node, it: fn(char) -> bool) -> bool { + pub fn loop_chars(node: @Node, it: fn(char) -> bool) -> bool { return loop_leaves(node,|leaf| { str::all_between(*leaf.content, leaf.byte_offset, @@ -1061,7 +1059,7 @@ mod node { * `true` If execution proceeded correctly, `false` if it was interrupted, * that is if `it` returned `false` at any point. */ - fn loop_leaves(node: @Node, it: fn(Leaf) -> bool) -> bool{ + pub fn loop_leaves(node: @Node, it: fn(Leaf) -> bool) -> bool{ let mut current = node; loop { match (*current) { @@ -1092,7 +1090,7 @@ mod node { * proportional to the height of the rope + the (bounded) * length of the largest leaf. */ - fn char_at(node: @Node, pos: uint) -> char { + pub fn char_at(node: @Node, pos: uint) -> char { let mut node = node; let mut pos = pos; loop { @@ -1107,19 +1105,18 @@ mod node { }; } - mod leaf_iterator { - #[legacy_exports]; - type T = { + pub mod leaf_iterator { + pub type T = { stack: ~[mut @Node], mut stackpos: int }; - fn empty() -> T { + pub fn empty() -> T { let stack : ~[mut @Node] = ~[mut]; return {stack: move stack, mut stackpos: -1} } - fn start(node: @Node) -> T { + pub fn start(node: @Node) -> T { let stack = vec::to_mut(vec::from_elem(height(node)+1u, node)); return { stack: move stack, @@ -1127,7 +1124,7 @@ mod node { } } - fn next(it: &T) -> Option { + pub fn next(it: &T) -> Option { if it.stackpos < 0 { return option::None; } loop { let current = it.stack[it.stackpos]; @@ -1145,15 +1142,14 @@ mod node { } } - mod char_iterator { - #[legacy_exports]; - type T = { + pub mod char_iterator { + pub type T = { leaf_iterator: leaf_iterator::T, mut leaf: Option, mut leaf_byte_pos: uint }; - fn start(node: @Node) -> T { + pub fn start(node: @Node) -> T { return { leaf_iterator: leaf_iterator::start(node), mut leaf: option::None, @@ -1161,7 +1157,7 @@ mod node { } } - fn empty() -> T { + pub fn empty() -> T { return { leaf_iterator: leaf_iterator::empty(), mut leaf: option::None, @@ -1169,7 +1165,7 @@ mod node { } } - fn next(it: &T) -> Option { + pub fn next(it: &T) -> Option { loop { match (get_current_or_next_leaf(it)) { option::None => return option::None, @@ -1184,7 +1180,7 @@ mod node { }; } - fn get_current_or_next_leaf(it: &T) -> Option { + pub fn get_current_or_next_leaf(it: &T) -> Option { match ((*it).leaf) { option::Some(_) => return (*it).leaf, option::None => { @@ -1201,7 +1197,7 @@ mod node { } } - fn get_next_char_in_leaf(it: &T) -> Option { + pub fn get_next_char_in_leaf(it: &T) -> Option { match copy (*it).leaf { option::None => return option::None, option::Some(aleaf) => { @@ -1224,7 +1220,6 @@ mod node { #[cfg(test)] mod tests { - #[legacy_exports]; //Utility function, used for sanity check fn rope_to_string(r: Rope) -> ~str { diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 1100485e7f1..2e7f47e0af0 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -13,12 +13,12 @@ use map::Map; // requires this to be. type SmallIntMap_ = {v: DVec>}; -enum SmallIntMap { +pub enum SmallIntMap { SmallIntMap_(@SmallIntMap_) } /// Create a smallintmap -fn mk() -> SmallIntMap { +pub fn mk() -> SmallIntMap { let v = DVec(); return SmallIntMap_(@{v: move v}); } @@ -28,7 +28,7 @@ fn mk() -> SmallIntMap { * the specified key then the original value is replaced. */ #[inline(always)] -fn insert(self: SmallIntMap, key: uint, +val: T) { +pub fn insert(self: SmallIntMap, key: uint, +val: T) { //io::println(fmt!("%?", key)); self.v.grow_set_elt(key, &None, Some(val)); } @@ -37,7 +37,7 @@ fn insert(self: SmallIntMap, key: uint, +val: T) { * Get the value for the specified key. If the key does not exist * in the map then returns none */ -pure fn find(self: SmallIntMap, key: uint) -> Option { +pub pure fn find(self: SmallIntMap, key: uint) -> Option { if key < self.v.len() { return self.v.get_elt(key); } return None::; } @@ -49,7 +49,7 @@ pure fn find(self: SmallIntMap, key: uint) -> Option { * * If the key does not exist in the map */ -pure fn get(self: SmallIntMap, key: uint) -> T { +pub pure fn get(self: SmallIntMap, key: uint) -> T { match find(self, key) { None => { error!("smallintmap::get(): key not present"); @@ -60,7 +60,7 @@ pure fn get(self: SmallIntMap, key: uint) -> T { } /// Returns true if the map contains a value for the specified key -fn contains_key(self: SmallIntMap, key: uint) -> bool { +pub fn contains_key(self: SmallIntMap, key: uint) -> bool { return !find(self, key).is_none(); } @@ -139,6 +139,6 @@ impl SmallIntMap: ops::Index { } /// Cast the given smallintmap to a map::map -fn as_map(s: SmallIntMap) -> map::Map { +pub fn as_map(s: SmallIntMap) -> map::Map { s as map::Map:: } diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 5b181d2e4c0..a38d9772b5c 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -87,9 +87,7 @@ mod fun_treemap; mod list; #[legacy_exports] mod map; -#[legacy_exports] mod rope; -#[legacy_exports] mod smallintmap; mod sort; mod treemap; -- cgit 1.4.1-3-g733a5 From f33539e446d6f41d4a3296ed50a8f968e7950483 Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Wed, 3 Oct 2012 12:21:48 -0700 Subject: Remove uses of + mode from libstd More or less the same as my analogous commit for libcore. Had to remove the forbid(deprecated_modes) pragma from some files -- will restore it after the snapshot. --- src/libstd/arc.rs | 22 +++++++++--------- src/libstd/bitv.rs | 4 ++-- src/libstd/cell.rs | 6 ++--- src/libstd/dbg.rs | 8 +++---- src/libstd/deque.rs | 14 ++++++------ src/libstd/getopts.rs | 25 ++++++++++---------- src/libstd/json.rs | 4 ++-- src/libstd/list.rs | 2 +- src/libstd/map.rs | 52 +++++++++++++++++++++--------------------- src/libstd/net_tcp.rs | 14 ++++++------ src/libstd/net_url.rs | 12 +++++----- src/libstd/rope.rs | 4 ++-- src/libstd/smallintmap.rs | 20 ++++++++-------- src/libstd/std.rc | 3 --- src/libstd/sync.rs | 14 ++++++------ src/libstd/test.rs | 4 ++-- src/libstd/time.rs | 4 ++-- src/libstd/timer.rs | 4 ++-- src/libstd/uv_iotask.rs | 4 ++-- src/libstd/uv_ll.rs | 6 ++--- src/test/bench/graph500-bfs.rs | 2 +- 21 files changed, 113 insertions(+), 115 deletions(-) (limited to 'src/libstd/smallintmap.rs') diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs index 9d15deab660..60db62ce01a 100644 --- a/src/libstd/arc.rs +++ b/src/libstd/arc.rs @@ -1,5 +1,5 @@ // NB: transitionary, de-mode-ing. -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap /** * Concurrency-enabled mechanisms for sharing mutable and/or immutable state * between tasks. @@ -66,7 +66,7 @@ impl &Condvar { struct ARC { x: SharedMutableState } /// Create an atomically reference counted wrapper. -pub fn ARC(+data: T) -> ARC { +pub fn ARC(data: T) -> ARC { ARC { x: unsafe { shared_mutable_state(move data) } } } @@ -98,7 +98,7 @@ pub fn clone(rc: &ARC) -> ARC { * unwrap from a task that holds another reference to the same ARC; it is * guaranteed to deadlock. */ -fn unwrap(+rc: ARC) -> T { +fn unwrap(rc: ARC) -> T { let ARC { x: x } <- rc; unsafe { unwrap_shared_mutable_state(move x) } } @@ -113,14 +113,14 @@ struct MutexARCInner { lock: Mutex, failed: bool, data: T } struct MutexARC { x: SharedMutableState> } /// Create a mutex-protected ARC with the supplied data. -pub fn MutexARC(+user_data: T) -> MutexARC { +pub fn MutexARC(user_data: T) -> MutexARC { mutex_arc_with_condvars(move user_data, 1) } /** * Create a mutex-protected ARC with the supplied data and a specified number * of condvars (as sync::mutex_with_condvars). */ -pub fn mutex_arc_with_condvars(+user_data: T, +pub fn mutex_arc_with_condvars(user_data: T, num_condvars: uint) -> MutexARC { let data = MutexARCInner { lock: mutex_with_condvars(num_condvars), @@ -191,7 +191,7 @@ impl &MutexARC { * Will additionally fail if another task has failed while accessing the arc. */ // FIXME(#2585) make this a by-move method on the arc -pub fn unwrap_mutex_arc(+arc: MutexARC) -> T { +pub fn unwrap_mutex_arc(arc: MutexARC) -> T { let MutexARC { x: x } <- arc; let inner = unsafe { unwrap_shared_mutable_state(move x) }; let MutexARCInner { failed: failed, data: data, _ } <- inner; @@ -247,14 +247,14 @@ struct RWARC { } /// Create a reader/writer ARC with the supplied data. -pub fn RWARC(+user_data: T) -> RWARC { +pub fn RWARC(user_data: T) -> RWARC { rw_arc_with_condvars(move user_data, 1) } /** * Create a reader/writer ARC with the supplied data and a specified number * of condvars (as sync::rwlock_with_condvars). */ -pub fn rw_arc_with_condvars(+user_data: T, +pub fn rw_arc_with_condvars(user_data: T, num_condvars: uint) -> RWARC { let data = RWARCInner { lock: rwlock_with_condvars(num_condvars), @@ -334,7 +334,7 @@ impl &RWARC { * } * ~~~ */ - fn write_downgrade(blk: fn(+v: RWWriteMode) -> U) -> U { + fn write_downgrade(blk: fn(v: RWWriteMode) -> U) -> U { let state = unsafe { get_shared_mutable_state(&self.x) }; do borrow_rwlock(state).write_downgrade |write_mode| { check_poison(false, state.failed); @@ -344,7 +344,7 @@ impl &RWARC { } /// To be called inside of the write_downgrade block. - fn downgrade(+token: RWWriteMode/&a) -> RWReadMode/&a { + fn downgrade(token: RWWriteMode/&a) -> RWReadMode/&a { // The rwlock should assert that the token belongs to us for us. let state = unsafe { get_shared_immutable_state(&self.x) }; let RWWriteMode((data, t, _poison)) <- token; @@ -369,7 +369,7 @@ impl &RWARC { * in write mode. */ // FIXME(#2585) make this a by-move method on the arc -pub fn unwrap_rw_arc(+arc: RWARC) -> T { +pub fn unwrap_rw_arc(arc: RWARC) -> T { let RWARC { x: x, _ } <- arc; let inner = unsafe { unwrap_shared_mutable_state(move x) }; let RWARCInner { failed: failed, data: data, _ } <- inner; diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs index bb556ed2ca3..77f0d39c338 100644 --- a/src/libstd/bitv.rs +++ b/src/libstd/bitv.rs @@ -1,4 +1,4 @@ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap use vec::{to_mut, from_elem}; @@ -95,7 +95,7 @@ struct BigBitv { mut storage: ~[mut uint] } -fn BigBitv(+storage: ~[mut uint]) -> BigBitv { +fn BigBitv(storage: ~[mut uint]) -> BigBitv { BigBitv {storage: storage} } diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs index 43e47e1e1a9..866dbce1c08 100644 --- a/src/libstd/cell.rs +++ b/src/libstd/cell.rs @@ -1,4 +1,4 @@ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap /// A dynamic, mutable location. /// /// Similar to a mutable option type, but friendlier. @@ -8,7 +8,7 @@ pub struct Cell { } /// Creates a new full cell with the given value. -pub fn Cell(+value: T) -> Cell { +pub fn Cell(value: T) -> Cell { Cell { value: Some(move value) } } @@ -29,7 +29,7 @@ impl Cell { } /// Returns the value, failing if the cell is full. - fn put_back(+value: T) { + fn put_back(value: T) { if !self.is_empty() { fail ~"attempt to put a value back into a full cell"; } diff --git a/src/libstd/dbg.rs b/src/libstd/dbg.rs index df97df51643..f85d4655ad1 100644 --- a/src/libstd/dbg.rs +++ b/src/libstd/dbg.rs @@ -1,4 +1,4 @@ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap //! Unsafe debugging functions for inspecting values. use cast::reinterpret_cast; @@ -20,7 +20,7 @@ pub fn debug_tydesc() { rustrt::debug_tydesc(sys::get_type_desc::()); } -pub fn debug_opaque(+x: T) { +pub fn debug_opaque(x: T) { rustrt::debug_opaque(sys::get_type_desc::(), ptr::addr_of(&x) as *()); } @@ -28,11 +28,11 @@ pub fn debug_box(x: @T) { rustrt::debug_box(sys::get_type_desc::(), ptr::addr_of(&x) as *()); } -pub fn debug_tag(+x: T) { +pub fn debug_tag(x: T) { rustrt::debug_tag(sys::get_type_desc::(), ptr::addr_of(&x) as *()); } -pub fn debug_fn(+x: T) { +pub fn debug_fn(x: T) { rustrt::debug_fn(sys::get_type_desc::(), ptr::addr_of(&x) as *()); } diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index da05174a6f5..f4fbc11c4f7 100644 --- a/src/libstd/deque.rs +++ b/src/libstd/deque.rs @@ -1,5 +1,5 @@ //! A deque. Untested as of yet. Likely buggy -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap #[forbid(non_camel_case_types)]; use option::{Some, None}; @@ -8,8 +8,8 @@ use core::cmp::{Eq}; pub trait Deque { fn size() -> uint; - fn add_front(+v: T); - fn add_back(+v: T); + fn add_front(v: T); + fn add_back(v: T); fn pop_front() -> T; fn pop_back() -> T; fn peek_front() -> T; @@ -27,7 +27,7 @@ pub fn create() -> Deque { * Grow is only called on full elts, so nelts is also len(elts), unlike * elsewhere. */ - fn grow(nelts: uint, lo: uint, +elts: ~[Cell]) + fn grow(nelts: uint, lo: uint, elts: ~[Cell]) -> ~[Cell] { let mut elts = move elts; assert (nelts == vec::len(elts)); @@ -55,7 +55,7 @@ pub fn create() -> Deque { impl Repr: Deque { fn size() -> uint { return self.nelts; } - fn add_front(+t: T) { + fn add_front(t: T) { let oldlo: uint = self.lo; if self.lo == 0u { self.lo = self.elts.len() - 1u; @@ -68,7 +68,7 @@ pub fn create() -> Deque { self.elts.set_elt(self.lo, Some(t)); self.nelts += 1u; } - fn add_back(+t: T) { + fn add_back(t: T) { if self.lo == self.hi && self.nelts != 0u { self.elts.swap(|v| grow(self.nelts, self.lo, move v)); self.lo = 0u; @@ -200,7 +200,7 @@ mod tests { assert (deq.get(3) == d); } - fn test_parameterized(+a: T, +b: T, +c: T, +d: T) { + fn test_parameterized(a: T, +b: T, +c: T, +d: T) { let deq: deque::Deque = deque::create::(); assert (deq.size() == 0u); deq.add_front(a); diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs index 9d127f5db47..8fd775c4773 100644 --- a/src/libstd/getopts.rs +++ b/src/libstd/getopts.rs @@ -62,7 +62,7 @@ * } */ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap use core::cmp::Eq; use core::result::{Err, Ok}; @@ -179,7 +179,7 @@ pub enum Fail_ { } /// Convert a `fail_` enum into an error string -pub fn fail_str(+f: Fail_) -> ~str { +pub fn fail_str(f: Fail_) -> ~str { return match f { ArgumentMissing(ref nm) => { ~"Argument to option '" + *nm + ~"' missing." @@ -335,7 +335,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe { free: free}); } -fn opt_vals(+mm: Matches, nm: &str) -> ~[Optval] { +fn opt_vals(mm: Matches, nm: &str) -> ~[Optval] { return match find_opt(mm.opts, mkname(nm)) { Some(id) => mm.vals[id], None => { @@ -345,15 +345,15 @@ fn opt_vals(+mm: Matches, nm: &str) -> ~[Optval] { }; } -fn opt_val(+mm: Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; } +fn opt_val(mm: Matches, nm: &str) -> Optval { return opt_vals(mm, nm)[0]; } /// Returns true if an option was matched -pub fn opt_present(+mm: Matches, nm: &str) -> bool { +pub fn opt_present(mm: Matches, nm: &str) -> bool { return vec::len::(opt_vals(mm, nm)) > 0u; } /// Returns true if any of several options were matched -pub fn opts_present(+mm: Matches, names: &[~str]) -> bool { +pub fn opts_present(mm: Matches, names: &[~str]) -> bool { for vec::each(names) |nm| { match find_opt(mm.opts, mkname(*nm)) { Some(_) => return true, @@ -370,7 +370,7 @@ pub fn opts_present(+mm: Matches, names: &[~str]) -> bool { * Fails if the option was not matched or if the match did not take an * argument */ -pub fn opt_str(+mm: Matches, nm: &str) -> ~str { +pub fn opt_str(mm: Matches, nm: &str) -> ~str { return match opt_val(mm, nm) { Val(copy s) => s, _ => fail }; } @@ -380,7 +380,8 @@ pub fn opt_str(+mm: Matches, nm: &str) -> ~str { * Fails if the no option was provided from the given list, or if the no such * option took an argument */ -pub fn opts_str(+mm: Matches, names: &[~str]) -> ~str { +pub fn opts_str(mm: Matches, names: &[~str]) -> ~str { +>>>>>>> Remove uses of + mode from libstd for vec::each(names) |nm| { match opt_val(mm, *nm) { Val(copy s) => return s, @@ -397,7 +398,7 @@ pub fn opts_str(+mm: Matches, names: &[~str]) -> ~str { * * Used when an option accepts multiple values. */ -pub fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] { +pub fn opt_strs(mm: Matches, nm: &str) -> ~[~str] { let mut acc: ~[~str] = ~[]; for vec::each(opt_vals(mm, nm)) |v| { match *v { Val(copy s) => acc.push(s), _ => () } @@ -406,7 +407,7 @@ pub fn opt_strs(+mm: Matches, nm: &str) -> ~[~str] { } /// Returns the string argument supplied to a matching option or none -pub fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> { +pub fn opt_maybe_str(mm: Matches, nm: &str) -> Option<~str> { let vals = opt_vals(mm, nm); if vec::len::(vals) == 0u { return None::<~str>; } return match vals[0] { @@ -423,7 +424,7 @@ pub fn opt_maybe_str(+mm: Matches, nm: &str) -> Option<~str> { * present but no argument was provided, and the argument if the option was * present and an argument was provided. */ -pub fn opt_default(+mm: Matches, nm: &str, def: &str) -> Option<~str> { +pub fn opt_default(mm: Matches, nm: &str, def: &str) -> Option<~str> { let vals = opt_vals(mm, nm); if vec::len::(vals) == 0u { return None::<~str>; } return match vals[0] { Val(copy s) => Some::<~str>(s), @@ -451,7 +452,7 @@ mod tests { use opt = getopts; use result::{Err, Ok}; - fn check_fail_type(+f: Fail_, ft: FailType) { + fn check_fail_type(f: Fail_, ft: FailType) { match f { ArgumentMissing(_) => assert ft == ArgumentMissing_, UnrecognizedOption(_) => assert ft == UnrecognizedOption_, diff --git a/src/libstd/json.rs b/src/libstd/json.rs index d3713bdb29d..f244f2869a6 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -1,6 +1,6 @@ // Rust JSON serialization library // Copyright (c) 2011 Google Inc. -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap #[forbid(non_camel_case_types)]; //! json serialization @@ -370,7 +370,7 @@ priv impl Parser { self.ch } - fn error(+msg: ~str) -> Result { + fn error(msg: ~str) -> Result { Err(Error { line: self.line, col: self.col, msg: @msg }) } diff --git a/src/libstd/list.rs b/src/libstd/list.rs index 5b0931ebdee..4ff493f5ab9 100644 --- a/src/libstd/list.rs +++ b/src/libstd/list.rs @@ -29,7 +29,7 @@ pub fn from_vec(v: &[T]) -> @List { * * z - The initial value * * f - The function to apply */ -pub fn foldl(+z: T, ls: @List, f: fn((&T), (&U)) -> T) -> T { +pub fn foldl(z: T, ls: @List, f: fn((&T), (&U)) -> T) -> T { let mut accum: T = z; do iter(ls) |elt| { accum = f(&accum, elt);} accum diff --git a/src/libstd/map.rs b/src/libstd/map.rs index 84fee092562..cc42c562376 100644 --- a/src/libstd/map.rs +++ b/src/libstd/map.rs @@ -1,6 +1,6 @@ //! A map type -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap use io::WriterUtil; use to_str::ToStr; @@ -28,10 +28,10 @@ pub trait Map { * * Returns true if the key did not already exist in the map */ - fn insert(+v: K, +v: 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; + fn contains_key(key: K) -> bool; /// Returns true if the map contains a value for the specified /// key, taking the key by reference. @@ -41,31 +41,31 @@ pub trait Map { * Get the value for the specified key. Fails if the key does not exist in * the map. */ - fn get(+key: K) -> V; + fn get(key: K) -> V; /** * Get the value for the specified key. If the key does not exist in * the map then returns none. */ - pure fn find(+key: K) -> Option; + pure fn find(key: K) -> Option; /** * Remove and return a value from the map. Returns true if the * key was present in the map, otherwise false. */ - fn remove(+key: K) -> bool; + fn remove(key: K) -> bool; /// Clear the map, removing all key/value pairs. fn clear(); /// Iterate over all the key/value pairs in the map by value - pure fn each(fn(+key: K, +value: V) -> bool); + pure fn each(fn(key: K, +value: V) -> bool); /// Iterate over all the keys in the map by value - pure fn each_key(fn(+key: K) -> bool); + pure fn each_key(fn(key: K) -> bool); /// Iterate over all the values in the map by value - pure fn each_value(fn(+value: V) -> bool); + pure fn each_value(fn(value: V) -> bool); /// Iterate over all the key/value pairs in the map by reference pure fn each_ref(fn(key: &K, value: &V) -> bool); @@ -201,7 +201,7 @@ pub mod chained { impl T: Map { pure fn size() -> uint { self.count } - fn contains_key(+k: K) -> bool { + fn contains_key(k: K) -> bool { self.contains_key_ref(&k) } @@ -213,7 +213,7 @@ pub mod chained { } } - fn insert(+k: K, +v: V) -> bool { + fn insert(k: K, +v: V) -> bool { let hash = k.hash_keyed(0,0) as uint; match self.search_tbl(&k, hash) { NotFound => { @@ -255,7 +255,7 @@ pub mod chained { } } - pure fn find(+k: K) -> Option { + pure fn find(k: K) -> Option { unsafe { match self.search_tbl(&k, k.hash_keyed(0,0) as uint) { NotFound => None, @@ -265,7 +265,7 @@ pub mod chained { } } - fn get(+k: K) -> V { + fn get(k: K) -> V { let opt_v = self.find(k); if opt_v.is_none() { fail fmt!("Key not found in table: %?", k); @@ -273,7 +273,7 @@ pub mod chained { option::unwrap(move opt_v) } - fn remove(+k: K) -> bool { + fn remove(k: K) -> bool { match self.search_tbl(&k, k.hash_keyed(0,0) as uint) { NotFound => false, FoundFirst(idx, entry) => { @@ -294,15 +294,15 @@ pub mod chained { self.chains = chains(initial_capacity); } - pure fn each(blk: fn(+key: K, +value: V) -> bool) { + pure fn each(blk: fn(key: K, +value: V) -> bool) { self.each_ref(|k, v| blk(*k, *v)) } - pure fn each_key(blk: fn(+key: K) -> bool) { + pure fn each_key(blk: fn(key: K) -> bool) { self.each_key_ref(|p| blk(*p)) } - pure fn each_value(blk: fn(+value: V) -> bool) { + pure fn each_value(blk: fn(value: V) -> bool) { self.each_value_ref(|p| blk(*p)) } @@ -377,7 +377,7 @@ pub fn HashMap() } /// Convenience function for adding keys to a hashmap with nil type keys -pub fn set_add(set: Set, +key: K) -> bool { +pub fn set_add(set: Set, key: K) -> bool { set.insert(key, ()) } @@ -415,13 +415,13 @@ impl @Mut>: } } - fn insert(+key: K, +value: V) -> bool { + fn insert(key: K, value: V) -> bool { do self.borrow_mut |p| { p.insert(key, value) } } - fn contains_key(+key: K) -> bool { + fn contains_key(key: K) -> bool { do self.borrow_const |p| { p.contains_key(&key) } @@ -433,13 +433,13 @@ impl @Mut>: } } - fn get(+key: K) -> V { + fn get(key: K) -> V { do self.borrow_const |p| { p.get(&key) } } - pure fn find(+key: K) -> Option { + pure fn find(key: K) -> Option { unsafe { do self.borrow_const |p| { p.find(&key) @@ -447,7 +447,7 @@ impl @Mut>: } } - fn remove(+key: K) -> bool { + fn remove(key: K) -> bool { do self.borrow_mut |p| { p.remove(&key) } @@ -459,7 +459,7 @@ impl @Mut>: } } - pure fn each(op: fn(+key: K, +value: V) -> bool) { + pure fn each(op: fn(key: K, +value: V) -> bool) { unsafe { do self.borrow_imm |p| { p.each(|k, v| op(*k, *v)) @@ -467,7 +467,7 @@ impl @Mut>: } } - pure fn each_key(op: fn(+key: K) -> bool) { + pure fn each_key(op: fn(key: K) -> bool) { unsafe { do self.borrow_imm |p| { p.each_key(|k| op(*k)) @@ -475,7 +475,7 @@ impl @Mut>: } } - pure fn each_value(op: fn(+value: V) -> bool) { + pure fn each_value(op: fn(value: V) -> bool) { unsafe { do self.borrow_imm |p| { p.each_value(|v| op(*v)) diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 59cb0d36f77..be38f16aff7 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -129,7 +129,7 @@ enum TcpConnectErrData { * the remote host. In the event of failure, a * `net::tcp::tcp_connect_err_data` instance will be returned */ -fn connect(+input_ip: ip::IpAddr, port: uint, +fn connect(input_ip: ip::IpAddr, port: uint, iotask: IoTask) -> result::Result unsafe { let result_po = core::comm::Port::(); @@ -570,7 +570,7 @@ fn accept(new_conn: TcpNewConnection) * successful/normal shutdown, and a `tcp_listen_err_data` enum in the event * of listen exiting because of an error */ -fn listen(+host_ip: ip::IpAddr, port: uint, backlog: uint, +fn listen(host_ip: ip::IpAddr, port: uint, backlog: uint, iotask: IoTask, +on_establish_cb: fn~(comm::Chan>), +new_connect_cb: fn~(TcpNewConnection, @@ -587,7 +587,7 @@ fn listen(+host_ip: ip::IpAddr, port: uint, backlog: uint, } } -fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint, +fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint, iotask: IoTask, +on_establish_cb: fn~(comm::Chan>), +on_connect_cb: fn~(*uv::ll::uv_tcp_t)) @@ -728,7 +728,7 @@ fn listen_common(+host_ip: ip::IpAddr, port: uint, backlog: uint, * * A buffered wrapper that you can cast as an `io::reader` or `io::writer` */ -fn socket_buf(+sock: TcpSocket) -> TcpSocketBuf { +fn socket_buf(sock: TcpSocket) -> TcpSocketBuf { TcpSocketBuf(@{ sock: move sock, mut buf: ~[] }) } @@ -738,7 +738,7 @@ impl TcpSocket { result::Result<~[u8], TcpErrData>>, TcpErrData> { read_start(&self) } - fn read_stop(+read_port: + fn read_stop(read_port: comm::Port>) -> result::Result<(), TcpErrData> { read_stop(&self, move read_port) @@ -1476,7 +1476,7 @@ mod test { */ } - fn buf_write(+w: &W, val: &str) { + fn buf_write(w: &W, val: &str) { log(debug, fmt!("BUF_WRITE: val len %?", str::len(val))); do str::byte_slice(val) |b_slice| { log(debug, fmt!("BUF_WRITE: b_slice len %?", @@ -1485,7 +1485,7 @@ mod test { } } - fn buf_read(+r: &R, len: uint) -> ~str { + fn buf_read(r: &R, len: uint) -> ~str { let new_bytes = (*r).read_bytes(len); log(debug, fmt!("in buf_read.. new_bytes len: %?", vec::len(new_bytes))); diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs index 920751d690f..6dca075405b 100644 --- a/src/libstd/net_url.rs +++ b/src/libstd/net_url.rs @@ -1,5 +1,5 @@ //! Types/fns concerning URLs (see RFC 3986) -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after a snapshot use core::cmp::Eq; use map::HashMap; @@ -36,7 +36,7 @@ type UserInfo = { type Query = ~[(~str, ~str)]; -fn Url(+scheme: ~str, +user: Option, +host: ~str, +fn Url(scheme: ~str, +user: Option, +host: ~str, +port: Option<~str>, +path: ~str, +query: Query, +fragment: Option<~str>) -> Url { Url { scheme: move scheme, user: move user, host: move host, @@ -44,7 +44,7 @@ fn Url(+scheme: ~str, +user: Option, +host: ~str, fragment: move fragment } } -fn UserInfo(+user: ~str, +pass: Option<~str>) -> UserInfo { +fn UserInfo(user: ~str, +pass: Option<~str>) -> UserInfo { {user: move user, pass: move pass} } @@ -306,7 +306,7 @@ fn userinfo_from_str(uinfo: &str) -> UserInfo { return UserInfo(user, pass); } -fn userinfo_to_str(+userinfo: UserInfo) -> ~str { +fn userinfo_to_str(userinfo: UserInfo) -> ~str { if option::is_some(&userinfo.pass) { return str::concat(~[copy userinfo.user, ~":", option::unwrap(copy userinfo.pass), @@ -334,7 +334,7 @@ fn query_from_str(rawquery: &str) -> Query { return query; } -fn query_to_str(+query: Query) -> ~str { +fn query_to_str(query: Query) -> ~str { let mut strvec = ~[]; for query.each |kv| { let (k, v) = copy *kv; @@ -681,7 +681,7 @@ impl Url : FromStr { * result in just "http://somehost.com". * */ -fn to_str(+url: Url) -> ~str { +fn to_str(url: Url) -> ~str { let user = if url.user.is_some() { userinfo_to_str(option::unwrap(copy url.user)) } else { diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index d14a4854555..5df4fc10a03 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -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(+c: 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(+c: 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, diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index 2e7f47e0af0..58ecbb0d6c3 100644 --- a/src/libstd/smallintmap.rs +++ b/src/libstd/smallintmap.rs @@ -2,7 +2,7 @@ * A simple map based on a vector for small integer keys. Space requirements * are O(highest integer key). */ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap use core::option; use core::option::{Some, None}; @@ -28,7 +28,7 @@ pub fn mk() -> SmallIntMap { * the specified key then the original value is replaced. */ #[inline(always)] -pub fn insert(self: SmallIntMap, key: uint, +val: T) { +pub fn insert(self: SmallIntMap, key: uint, val: T) { //io::println(fmt!("%?", key)); self.v.grow_set_elt(key, &None, Some(val)); } @@ -77,12 +77,12 @@ impl SmallIntMap: map::Map { sz } #[inline(always)] - fn insert(+key: uint, +value: V) -> bool { + fn insert(key: uint, value: V) -> bool { let exists = contains_key(self, key); insert(self, key, value); return !exists; } - fn remove(+key: uint) -> bool { + fn remove(key: uint) -> bool { if key >= self.v.len() { return false; } @@ -93,23 +93,23 @@ impl SmallIntMap: map::Map { fn clear() { self.v.set(~[]); } - fn contains_key(+key: uint) -> bool { + fn contains_key(key: uint) -> bool { contains_key(self, key) } fn contains_key_ref(key: &uint) -> bool { contains_key(self, *key) } - fn get(+key: uint) -> V { get(self, key) } - pure fn find(+key: uint) -> Option { find(self, key) } + fn get(key: uint) -> V { get(self, key) } + pure fn find(key: uint) -> Option { find(self, key) } fn rehash() { fail } - pure fn each(it: fn(+key: uint, +value: V) -> bool) { + pure fn each(it: fn(key: uint, +value: V) -> bool) { self.each_ref(|k, v| it(*k, *v)) } - pure fn each_key(it: fn(+key: uint) -> bool) { + pure fn each_key(it: fn(key: uint) -> bool) { self.each_ref(|k, _v| it(*k)) } - pure fn each_value(it: fn(+value: V) -> bool) { + pure fn each_value(it: fn(value: V) -> bool) { self.each_ref(|_k, v| it(*v)) } pure fn each_ref(it: fn(key: &uint, value: &V) -> bool) { diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 202cb4932db..683ea589b91 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -18,9 +18,6 @@ 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)]; diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index f66f2f5b5d3..f66134d3892 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -1,5 +1,5 @@ // NB: transitionary, de-mode-ing. -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap /** * The concurrency primitives you know and love. * @@ -69,7 +69,7 @@ struct SemInner { enum Sem = Exclusive>; #[doc(hidden)] -fn new_sem(count: int, +q: Q) -> Sem { +fn new_sem(count: int, q: Q) -> Sem { Sem(exclusive(SemInner { mut count: count, waiters: new_waitqueue(), blocked: q })) } @@ -535,7 +535,7 @@ impl &RWlock { * } * ~~~ */ - fn write_downgrade(blk: fn(+v: RWlockWriteMode) -> U) -> U { + fn write_downgrade(blk: fn(v: RWlockWriteMode) -> U) -> U { // Implementation slightly different from the slicker 'write's above. // The exit path is conditional on whether the caller downgrades. let mut _release = None; @@ -551,7 +551,7 @@ impl &RWlock { } /// To be called inside of the write_downgrade block. - fn downgrade(+token: RWlockWriteMode/&a) -> RWlockReadMode/&a { + fn downgrade(token: RWlockWriteMode/&a) -> RWlockReadMode/&a { if !ptr::ref_eq(self, token.lock) { fail ~"Can't downgrade() with a different rwlock's write_mode!"; } @@ -957,7 +957,7 @@ mod tests { drop { self.c.send(()); } } - fn SendOnFailure(+c: pipes::Chan<()>) -> SendOnFailure { + fn SendOnFailure(c: pipes::Chan<()>) -> SendOnFailure { SendOnFailure { c: c } @@ -1038,7 +1038,7 @@ mod tests { } } #[cfg(test)] - fn test_rwlock_exclusion(+x: ~RWlock, mode1: RWlockMode, + fn test_rwlock_exclusion(x: ~RWlock, mode1: RWlockMode, mode2: RWlockMode) { // Test mutual exclusion between readers and writers. Just like the // mutex mutual exclusion test, a ways above. @@ -1083,7 +1083,7 @@ mod tests { test_rwlock_exclusion(~RWlock(), Downgrade, Downgrade); } #[cfg(test)] - fn test_rwlock_handshake(+x: ~RWlock, mode1: RWlockMode, + fn test_rwlock_handshake(x: ~RWlock, mode1: RWlockMode, mode2: RWlockMode, make_mode2_go_first: bool) { // Much like sem_multi_resource. let x2 = ~x.clone(); diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 1df10a4d799..c5d9dd343fa 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -270,7 +270,7 @@ enum TestEvent { type MonitorMsg = (TestDesc, TestResult); fn run_tests(opts: &TestOpts, tests: &[TestDesc], - callback: fn@(+e: TestEvent)) { + callback: fn@(e: TestEvent)) { let mut filtered_tests = filter_tests(opts, tests); callback(TeFiltered(copy filtered_tests)); @@ -379,7 +379,7 @@ fn filter_tests(opts: &TestOpts, type TestFuture = {test: TestDesc, wait: fn@() -> TestResult}; -fn run_test(+test: TestDesc, monitor_ch: comm::Chan) { +fn run_test(test: TestDesc, monitor_ch: comm::Chan) { if test.ignore { core::comm::send(monitor_ch, (copy test, TrIgnored)); return; diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 43cbc6da9bd..aef3bb2ac0a 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -1,4 +1,4 @@ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap use core::cmp::Eq; use libc::{c_char, c_int, c_long, size_t, time_t}; @@ -589,7 +589,7 @@ pub fn strptime(s: &str, format: &str) -> Result { } } -fn strftime(format: &str, +tm: Tm) -> ~str { +fn strftime(format: &str, tm: Tm) -> ~str { fn parse_type(ch: char, tm: &Tm) -> ~str { //FIXME (#2350): Implement missing types. let die = || #fmt("strftime: can't understand this format %c ", diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs index 8aaf7d3fd87..2aca87b942e 100644 --- a/src/libstd/timer.rs +++ b/src/libstd/timer.rs @@ -1,6 +1,6 @@ //! Utilities that leverage libuv's `uv_timer_*` API -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after snap use uv = uv; use uv::iotask; @@ -24,7 +24,7 @@ use comm = core::comm; * * val - a value of type T to send over the provided `ch` */ pub fn delayed_send(iotask: IoTask, - msecs: uint, ch: comm::Chan, +val: T) { + msecs: uint, ch: comm::Chan, val: T) { unsafe { let timer_done_po = core::comm::Port::<()>(); let timer_done_ch = core::comm::Chan(timer_done_po); diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs index 876aa6f4af0..4a4a34704be 100644 --- a/src/libstd/uv_iotask.rs +++ b/src/libstd/uv_iotask.rs @@ -5,7 +5,7 @@ * `interact` function you can execute code in a uv callback. */ -#[forbid(deprecated_mode)]; +// tjc: forbid deprecated modes again after a snapshot use libc::c_void; use ptr::p2::addr_of; @@ -22,7 +22,7 @@ pub enum IoTask { }) } -pub fn spawn_iotask(+task: task::TaskBuilder) -> IoTask { +pub fn spawn_iotask(task: task::TaskBuilder) -> IoTask { do listen |iotask_ch| { diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index f0594475d04..50636054821 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -642,7 +642,7 @@ extern mod rustrt { fn rust_uv_addrinfo_as_sockaddr_in(input: *addrinfo) -> *sockaddr_in; fn rust_uv_addrinfo_as_sockaddr_in6(input: *addrinfo) -> *sockaddr_in6; fn rust_uv_malloc_buf_base_of(sug_size: libc::size_t) -> *u8; - fn rust_uv_free_base_of_buf(++buf: uv_buf_t); + fn rust_uv_free_base_of_buf(+buf: uv_buf_t); fn rust_uv_get_stream_handle_from_connect_req( connect_req: *uv_connect_t) -> *uv_stream_t; @@ -661,8 +661,8 @@ extern mod rustrt { fn rust_uv_get_data_for_req(req: *libc::c_void) -> *libc::c_void; fn rust_uv_set_data_for_req(req: *libc::c_void, data: *libc::c_void); - fn rust_uv_get_base_from_buf(++buf: uv_buf_t) -> *u8; - fn rust_uv_get_len_from_buf(++buf: uv_buf_t) -> libc::size_t; + fn rust_uv_get_base_from_buf(+buf: uv_buf_t) -> *u8; + fn rust_uv_get_len_from_buf(+buf: uv_buf_t) -> libc::size_t; // sizeof testing helpers fn rust_uv_helper_uv_tcp_t_size() -> libc::c_uint; diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index f35a3ce735f..a34fcc89c04 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -251,7 +251,7 @@ fn pbfs(&&graph: arc::ARC, 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); -- cgit 1.4.1-3-g733a5