squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

librustc: Replace impl Type : Trait with impl Trait for Type. rs=implflipping

Browse source
This commit is contained in:
Patrick Walton 2013-02-14 11:47:00 -08:00
parent 8ec6f43d6c
commit 9143688197
583 changed files with 1115 additions and 1115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/libcore/bool.rs
View file

@ -74,7 +74,7 @@ pub fn all_values(blk: fn(v: bool)) {
pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
#[cfg(notest)]
impl bool : cmp::Eq {
impl cmp::Eq for bool {
pure fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
pure fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
}

2
src/libcore/char.rs
View file

@ -251,7 +251,7 @@ pub pure fn cmp(a: char, b: char) -> int {
}
#[cfg(notest)]
impl char : Eq {
impl Eq for char {
pure fn eq(&self, other: &char) -> bool { (*self) == (*other) }
pure fn ne(&self, other: &char) -> bool { (*self) != (*other) }
}

2
src/libcore/clone.rs
View file

@ -15,7 +15,7 @@ pub trait Clone {
fn clone(&self) -> Self;
}
impl (): Clone {
impl Clone for () {
#[inline(always)]
fn clone(&self) -> () { () }
}

2
src/libcore/condition.rs
View file

@ -84,7 +84,7 @@ struct Guard<T, U> {
cond: &Condition<T, U>
}
impl<T, U> Guard<T, U> : Drop {
impl<T, U> Drop for Guard<T, U> {
fn finalize(&self) {
unsafe {
debug!("Guard: popping handler from TLS");

2
src/libcore/dvec.rs
View file

@ -358,7 +358,7 @@ impl<A: Copy> DVec<A> {
}
}
impl<A:Copy> DVec<A>: Index<uint,A> {
impl<A:Copy> Index<uint,A> for DVec<A> {
#[inline(always)]
pure fn index(&self, idx: uint) -> A {
self.get_elt(idx)

8
src/libcore/hash.rs
View file

@ -59,7 +59,7 @@ pub trait HashUtil {
pure fn hash() -> u64;
}
impl <A: Hash> A: HashUtil {
impl<A: Hash> HashUtil for A {
#[inline(always)]
pure fn hash() -> u64 { self.hash_keyed(0,0) }
}
@ -74,7 +74,7 @@ pub trait Streaming {
fn reset();
}
impl <A: IterBytes> A: Hash {
impl<A: IterBytes> Hash for A {
#[inline(always)]
pure fn hash_keyed(k0: u64, k1: u64) -> u64 {
unsafe {
@ -187,7 +187,7 @@ fn SipState(key0: u64, key1: u64) -> SipState {
}
impl SipState : io::Writer {
impl io::Writer for SipState {
// Methods for io::writer
#[inline(always)]
@ -295,7 +295,7 @@ impl SipState : io::Writer {
}
}
impl &SipState : Streaming {
impl Streaming for &SipState {
#[inline(always)]
fn input(buf: &[const u8]) {

20
src/libcore/hashmap.rs
View file

@ -240,7 +240,7 @@ pub mod linear {
}
}
impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: BaseIter<(&K, &V)> {
impl<K: Hash IterBytes Eq, V> BaseIter<(&K, &V)> for LinearMap<K, V> {
/// Visit all key-value pairs
pure fn each(&self, blk: fn(&(&self/K, &self/V)) -> bool) {
for uint::range(0, self.buckets.len()) |i| {
@ -257,7 +257,7 @@ pub mod linear {
}
impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Container {
impl<K: Hash IterBytes Eq, V> Container for LinearMap<K, V> {
/// Return the number of elements in the map
pure fn len(&self) -> uint { self.size }
@ -265,7 +265,7 @@ pub mod linear {
pure fn is_empty(&self) -> bool { self.len() == 0 }
}
impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Mutable {
impl<K: Hash IterBytes Eq, V> Mutable for LinearMap<K, V> {
/// Clear the map, removing all key-value pairs.
fn clear(&mut self) {
for uint::range(0, self.buckets.len()) |idx| {
@ -275,7 +275,7 @@ pub mod linear {
}
}
impl <K: Hash IterBytes Eq, V> LinearMap<K, V>: Map<K, V> {
impl<K: Hash IterBytes Eq, V> Map<K, V> for LinearMap<K, V> {
/// Return true if the map contains a value for the specified key
pure fn contains_key(&self, k: &K) -> bool {
match self.bucket_for_key(k) {
@ -443,7 +443,7 @@ pub mod linear {
}
}
impl<K: Hash IterBytes Eq, V: Eq> LinearMap<K, V>: Eq {
impl<K: Hash IterBytes Eq, V: Eq> Eq for LinearMap<K, V> {
pure fn eq(&self, other: &LinearMap<K, V>) -> bool {
if self.len() != other.len() { return false; }
@ -464,13 +464,13 @@ pub mod linear {
priv map: LinearMap<T, ()>
}
impl <T: Hash IterBytes Eq> LinearSet<T>: BaseIter<T> {
impl<T: Hash IterBytes Eq> BaseIter<T> for LinearSet<T> {
/// Visit all values in order
pure fn each(&self, f: fn(&T) -> bool) { self.map.each_key(f) }
pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
impl <T: Hash IterBytes Eq> LinearSet<T>: Eq {
impl<T: Hash IterBytes Eq> Eq for LinearSet<T> {
pure fn eq(&self, other: &LinearSet<T>) -> bool {
self.map == other.map
}
@ -479,7 +479,7 @@ pub mod linear {
}
}
impl <T: Hash IterBytes Eq> LinearSet<T>: Container {
impl<T: Hash IterBytes Eq> Container for LinearSet<T> {
/// Return the number of elements in the set
pure fn len(&self) -> uint { self.map.len() }
@ -487,12 +487,12 @@ pub mod linear {
pure fn is_empty(&self) -> bool { self.map.is_empty() }
}
impl <T: Hash IterBytes Eq> LinearSet<T>: Mutable {
impl<T: Hash IterBytes Eq> Mutable for LinearSet<T> {
/// Clear the set, removing all values.
fn clear(&mut self) { self.map.clear() }
}
impl <T: Hash IterBytes Eq> LinearSet<T>: Set<T> {
impl<T: Hash IterBytes Eq> Set<T> for LinearSet<T> {
/// Return true if the set contains a value
pure fn contains(&self, value: &T) -> bool {
self.map.contains_key(value)

20
src/libcore/io.rs
View file

@ -169,7 +169,7 @@ pub trait ReaderUtil {
fn read_i8(&self) -> i8;
}
impl<T: Reader> T : ReaderUtil {
impl<T: Reader> ReaderUtil for T {
fn read_bytes(&self,len: uint) -> ~[u8] {
let mut bytes = vec::with_capacity(len);
@ -415,7 +415,7 @@ fn convert_whence(whence: SeekStyle) -> i32 {
};
}
impl *libc::FILE: Reader {
impl Reader for *libc::FILE {
fn read(&self, bytes: &mut [u8], len: uint) -> uint {
unsafe {
do vec::as_mut_buf(bytes) |buf_p, buf_len| {
@ -460,7 +460,7 @@ struct Wrapper<T, C> {
// A forwarding impl of reader that also holds on to a resource for the
// duration of its lifetime.
// FIXME there really should be a better way to do this // #2004
impl<R: Reader, C> Wrapper<R, C>: Reader {
impl<R: Reader, C> Reader for Wrapper<R, C> {
fn read(&self, bytes: &mut [u8], len: uint) -> uint {
self.base.read(bytes, len)
}
@ -527,7 +527,7 @@ pub struct BytesReader {
mut pos: uint
}
impl BytesReader: Reader {
impl Reader for BytesReader {
fn read(&self, bytes: &mut [u8], len: uint) -> uint {
let count = uint::min(len, self.bytes.len() - self.pos);
@ -589,7 +589,7 @@ pub trait Writer {
fn get_type(&self) -> WriterType;
}
impl<W: Writer, C> Wrapper<W, C>: Writer {
impl<W: Writer, C> Writer for Wrapper<W, C> {
fn write(&self, bs: &[const u8]) { self.base.write(bs); }
fn seek(&self, off: int, style: SeekStyle) { self.base.seek(off, style); }
fn tell(&self) -> uint { self.base.tell() }
@ -597,7 +597,7 @@ impl<W: Writer, C> Wrapper<W, C>: Writer {
fn get_type(&self) -> WriterType { File }
}
impl *libc::FILE: Writer {
impl Writer for *libc::FILE {
fn write(&self, v: &[const u8]) {
unsafe {
do vec::as_const_buf(v) |vbuf, len| {
@ -647,7 +647,7 @@ pub fn FILE_writer(f: *libc::FILE, cleanup: bool) -> Writer {
}
}
impl fd_t: Writer {
impl Writer for fd_t {
fn write(&self, v: &[const u8]) {
unsafe {
let mut count = 0u;
@ -890,7 +890,7 @@ pub trait WriterUtil {
fn write_i8(&self, n: i8);
}
impl<T: Writer> T : WriterUtil {
impl<T: Writer> WriterUtil for T {
fn write_char(&self, ch: char) {
if ch as uint < 128u {
self.write(&[ch as u8]);
@ -996,7 +996,7 @@ pub struct BytesWriter {
mut pos: uint,
}
impl BytesWriter: Writer {
impl Writer for BytesWriter {
fn write(&self, v: &[const u8]) {
do self.bytes.swap |bytes| {
let mut bytes = move bytes;
@ -1112,7 +1112,7 @@ pub mod fsync {
arg: Arg<t>,
}
impl<T: Copy> Res<T>: Drop {
impl<T: Copy> Drop for Res<T> {
fn finalize(&self) {
match self.arg.opt_level {
None => (),

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

@ -20,14 +20,14 @@ use option::Option;
use self::inst::{IMPL_T, EACH, SIZE_HINT};
impl<A> IMPL_T<A>: iter::BaseIter<A> {
impl<A> iter::BaseIter<A> for IMPL_T<A> {
#[inline(always)]
pure fn each(&self, blk: fn(v: &A) -> bool) { EACH(self, blk) }
#[inline(always)]
pure fn size_hint(&self) -> Option<uint> { SIZE_HINT(self) }
}
impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
impl<A> iter::ExtendedIter<A> for IMPL_T<A> {
#[inline(always)]
pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
iter::eachi(self, blk)
@ -60,14 +60,14 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
}
impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
impl<A: Eq> iter::EqIter<A> for IMPL_T<A> {
#[inline(always)]
pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
#[inline(always)]
pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
}
impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
impl<A: Copy> iter::CopyableIter<A> for IMPL_T<A> {
#[inline(always)]
pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
iter::filter_to_vec(self, pred)
@ -80,7 +80,7 @@ impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {
}
}
impl<A: Copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {
impl<A: Copy Ord> iter::CopyableOrderedIter<A> for IMPL_T<A> {
#[inline(always)]
pure fn min(&self) -> A { iter::min(self) }
#[inline(always)]

4
src/libcore/managed.rs
View file

@ -46,7 +46,7 @@ pub pure fn mut_ptr_eq<T>(a: @mut T, b: @mut T) -> bool {
}
#[cfg(notest)]
impl<T:Eq> @const T : Eq {
impl<T:Eq> Eq for @const T {
#[inline(always)]
pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
#[inline(always)]
@ -54,7 +54,7 @@ impl<T:Eq> @const T : Eq {
}
#[cfg(notest)]
impl<T:Ord> @const T : Ord {
impl<T:Ord> Ord for @const T {
#[inline(always)]
pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
#[inline(always)]

4
src/libcore/nil.rs
View file

@ -17,7 +17,7 @@ Functions for the unit type.
use cmp::{Eq, Ord};
#[cfg(notest)]
impl () : Eq {
impl Eq for () {
#[inline(always)]
pure fn eq(&self, _other: &()) -> bool { true }
#[inline(always)]
@ -25,7 +25,7 @@ impl () : Eq {
}
#[cfg(notest)]
impl () : Ord {
impl Ord for () {
#[inline(always)]
pure fn lt(&self, _other: &()) -> bool { false }
#[inline(always)]

18
src/libcore/num/f32.rs
View file

@ -253,7 +253,7 @@ pub pure fn logarithm(n: f32, b: f32) -> f32 {
}
#[cfg(notest)]
impl f32 : cmp::Eq {
impl cmp::Eq for f32 {
#[inline(always)]
pure fn eq(&self, other: &f32) -> bool { (*self) == (*other) }
#[inline(always)]
@ -261,7 +261,7 @@ impl f32 : cmp::Eq {
}
#[cfg(notest)]
impl f32 : cmp::Ord {
impl cmp::Ord for f32 {
#[inline(always)]
pure fn lt(&self, other: &f32) -> bool { (*self) < (*other) }
#[inline(always)]
@ -272,12 +272,12 @@ impl f32 : cmp::Ord {
pure fn gt(&self, other: &f32) -> bool { (*self) > (*other) }
}
impl f32: num::Zero {
impl num::Zero for f32 {
#[inline(always)]
static pure fn zero() -> f32 { 0.0 }
}
impl f32: num::One {
impl num::One for f32 {
#[inline(always)]
static pure fn one() -> f32 { 1.0 }
}
@ -336,7 +336,7 @@ pub extern {
fn floorf32(val: f32) -> f32;
}
impl f32: num::Round {
impl num::Round for f32 {
#[inline(always)]
pure fn round(&self, mode: num::RoundMode) -> f32 {
match mode {
@ -464,12 +464,12 @@ pub pure fn to_str_digits(num: f32, dig: uint) -> ~str {
r
}
impl f32: to_str::ToStr {
impl to_str::ToStr for f32 {
#[inline(always)]
pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
}
impl f32: num::ToStrRadix {
impl num::ToStrRadix for f32 {
#[inline(always)]
pure fn to_str_radix(&self, rdx: uint) -> ~str {
to_str_radix(*self, rdx)
@ -564,12 +564,12 @@ pub pure fn from_str_radix(num: &str, rdx: uint) -> Option<f32> {
num::from_str_common(num, rdx, true, true, false, num::ExpNone, false)
}
impl f32: from_str::FromStr {
impl from_str::FromStr for f32 {
#[inline(always)]
static pure fn from_str(val: &str) -> Option<f32> { from_str(val) }
}
impl f32: num::FromStrRadix {
impl num::FromStrRadix for f32 {
#[inline(always)]
static pure fn from_str_radix(val: &str, rdx: uint) -> Option<f32> {
from_str_radix(val, rdx)

18
src/libcore/num/f64.rs
View file

@ -278,7 +278,7 @@ pub pure fn logarithm(n: f64, b: f64) -> f64 {
}
#[cfg(notest)]
impl f64 : cmp::Eq {
impl cmp::Eq for f64 {
#[inline(always)]
pure fn eq(&self, other: &f64) -> bool { (*self) == (*other) }
#[inline(always)]
@ -286,7 +286,7 @@ impl f64 : cmp::Eq {
}
#[cfg(notest)]
impl f64 : cmp::Ord {
impl cmp::Ord for f64 {
#[inline(always)]
pure fn lt(&self, other: &f64) -> bool { (*self) < (*other) }
#[inline(always)]
@ -321,12 +321,12 @@ pub impl f64: NumCast {
#[inline(always)] pure fn to_float(&self) -> float { *self as float }
}
impl f64: num::Zero {
impl num::Zero for f64 {
#[inline(always)]
static pure fn zero() -> f64 { 0.0 }
}
impl f64: num::One {
impl num::One for f64 {
#[inline(always)]
static pure fn one() -> f64 { 1.0 }
}
@ -361,7 +361,7 @@ pub extern {
fn floorf64(val: f64) -> f64;
}
impl f64: num::Round {
impl num::Round for f64 {
#[inline(always)]
pure fn round(&self, mode: num::RoundMode) -> f64 {
match mode {
@ -489,12 +489,12 @@ pub pure fn to_str_digits(num: f64, dig: uint) -> ~str {
r
}
impl f64: to_str::ToStr {
impl to_str::ToStr for f64 {
#[inline(always)]
pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
}
impl f64: num::ToStrRadix {
impl num::ToStrRadix for f64 {
#[inline(always)]
pure fn to_str_radix(&self, rdx: uint) -> ~str {
to_str_radix(*self, rdx)
@ -589,12 +589,12 @@ pub pure fn from_str_radix(num: &str, rdx: uint) -> Option<f64> {
num::from_str_common(num, rdx, true, true, false, num::ExpNone, false)
}
impl f64: from_str::FromStr {
impl from_str::FromStr for f64 {
#[inline(always)]
static pure fn from_str(val: &str) -> Option<f64> { from_str(val) }
}
impl f64: num::FromStrRadix {
impl num::FromStrRadix for f64 {
#[inline(always)]
static pure fn from_str_radix(val: &str, rdx: uint) -> Option<f64> {
from_str_radix(val, rdx)

18
src/libcore/num/float.rs
View file

@ -201,12 +201,12 @@ pub pure fn to_str_digits(num: float, digits: uint) -> ~str {
r
}
impl float: to_str::ToStr {
impl to_str::ToStr for float {
#[inline(always)]
pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
}
impl float: num::ToStrRadix {
impl num::ToStrRadix for float {
#[inline(always)]
pure fn to_str_radix(&self, radix: uint) -> ~str {
to_str_radix(*self, radix)
@ -301,12 +301,12 @@ pub pure fn from_str_radix(num: &str, radix: uint) -> Option<float> {
num::from_str_common(num, radix, true, true, false, num::ExpNone, false)
}
impl float: from_str::FromStr {
impl from_str::FromStr for float {
#[inline(always)]
static pure fn from_str(val: &str) -> Option<float> { from_str(val) }
}
impl float: num::FromStrRadix {
impl num::FromStrRadix for float {
#[inline(always)]
static pure fn from_str_radix(val: &str, radix: uint) -> Option<float> {
from_str_radix(val, radix)
@ -392,25 +392,25 @@ pub pure fn tan(x: float) -> float {
}
#[cfg(notest)]
impl float : Eq {
impl Eq for float {
pure fn eq(&self, other: &float) -> bool { (*self) == (*other) }
pure fn ne(&self, other: &float) -> bool { (*self) != (*other) }
}
#[cfg(notest)]
impl float : Ord {
impl Ord for float {
pure fn lt(&self, other: &float) -> bool { (*self) < (*other) }
pure fn le(&self, other: &float) -> bool { (*self) <= (*other) }
pure fn ge(&self, other: &float) -> bool { (*self) >= (*other) }
pure fn gt(&self, other: &float) -> bool { (*self) > (*other) }
}
impl float: num::Zero {
impl num::Zero for float {
#[inline(always)]
static pure fn zero() -> float { 0.0 }
}
impl float: num::One {
impl num::One for float {
#[inline(always)]
static pure fn one() -> float { 1.0 }
}
@ -439,7 +439,7 @@ pub impl float: NumCast {
#[inline(always)] pure fn to_float(&self) -> float { *self }
}
impl float: num::Round {
impl num::Round for float {
#[inline(always)]
pure fn round(&self, mode: num::RoundMode) -> float {
match mode {

18
src/libcore/num/int-template.rs
View file

@ -147,7 +147,7 @@ pub pure fn abs(i: T) -> T {
}
#[cfg(notest)]
impl T : Ord {
impl Ord for T {
#[inline(always)]
pure fn lt(&self, other: &T) -> bool { return (*self) < (*other); }
#[inline(always)]
@ -159,24 +159,24 @@ impl T : Ord {
}
#[cfg(notest)]
impl T : Eq {
impl Eq for T {
#[inline(always)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
#[inline(always)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}
impl T: num::Zero {
impl num::Zero for T {
#[inline(always)]
static pure fn zero() -> T { 0 }
}
impl T: num::One {
impl num::One for T {
#[inline(always)]
static pure fn one() -> T { 1 }
}
impl T: num::Round {
impl num::Round for T {
#[inline(always)]
pure fn round(&self, _: num::RoundMode) -> T { *self }
@ -236,14 +236,14 @@ pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
num::ExpNone, false)
}
impl T : FromStr {
impl FromStr for T {
#[inline(always)]
static pure fn from_str(s: &str) -> Option<T> {
from_str(s)
}
}
impl T : FromStrRadix {
impl FromStrRadix for T {
#[inline(always)]
static pure fn from_str_radix(&self, s: &str, radix: uint) -> Option<T> {
from_str_radix(s, radix)
@ -281,14 +281,14 @@ pub pure fn to_str_radix(num: T, radix: uint) -> ~str {
#[inline(always)]
pub pure fn str(i: T) -> ~str { to_str(i) }
impl T : ToStr {
impl ToStr for T {
#[inline(always)]
pure fn to_str(&self) -> ~str {
to_str(*self)
}
}
impl T : ToStrRadix {
impl ToStrRadix for T {
#[inline(always)]
pure fn to_str_radix(&self, radix: uint) -> ~str {
to_str_radix(*self, radix)

18
src/libcore/num/uint-template.rs
View file

@ -111,7 +111,7 @@ pub pure fn compl(i: T) -> T {
}
#[cfg(notest)]
impl T : Ord {
impl Ord for T {
#[inline(always)]
pure fn lt(&self, other: &T) -> bool { (*self) < (*other) }
#[inline(always)]
@ -123,24 +123,24 @@ impl T : Ord {
}
#[cfg(notest)]
impl T : Eq {
impl Eq for T {
#[inline(always)]
pure fn eq(&self, other: &T) -> bool { return (*self) == (*other); }
#[inline(always)]
pure fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
}
impl T: num::Zero {
impl num::Zero for T {
#[inline(always)]
static pure fn zero() -> T { 0 }
}
impl T: num::One {
impl num::One for T {
#[inline(always)]
static pure fn one() -> T { 1 }
}
impl T: num::Round {
impl num::Round for T {
#[inline(always)]
pure fn round(&self, _: num::RoundMode) -> T { *self }
@ -200,14 +200,14 @@ pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
num::ExpNone, false)
}
impl T : FromStr {
impl FromStr for T {
#[inline(always)]
static pure fn from_str(s: &str) -> Option<T> {
from_str(s)
}
}
impl T : FromStrRadix {
impl FromStrRadix for T {
#[inline(always)]
static pure fn from_str_radix(&self, s: &str, radix: uint) -> Option<T> {
from_str_radix(s, radix)
@ -245,14 +245,14 @@ pub pure fn to_str_radix(num: T, radix: uint) -> ~str {
#[inline(always)]
pub pure fn str(i: T) -> ~str { to_str(i) }
impl T : ToStr {
impl ToStr for T {
#[inline(always)]
pure fn to_str(&self) -> ~str {
to_str(*self)
}
}
impl T : ToStrRadix {
impl ToStrRadix for T {
#[inline(always)]
pure fn to_str_radix(&self, radix: uint) -> ~str {
to_str_radix(*self, radix)

4
src/libcore/owned.rs
View file

@ -13,7 +13,7 @@
use cmp::{Eq, Ord};
#[cfg(notest)]
impl<T:Eq> ~const T : Eq {
impl<T:Eq> Eq for ~const T {
#[inline(always)]
pure fn eq(&self, other: &~const T) -> bool { *(*self) == *(*other) }
#[inline(always)]
@ -21,7 +21,7 @@ impl<T:Eq> ~const T : Eq {
}
#[cfg(notest)]
impl<T:Ord> ~const T : Ord {
impl<T:Ord> Ord for ~const T {
#[inline(always)]
pure fn lt(&self, other: &~const T) -> bool { *(*self) < *(*other) }
#[inline(always)]

8
src/libcore/path.rs
View file

@ -363,7 +363,7 @@ impl Path {
}
}
impl PosixPath : ToStr {
impl ToStr for PosixPath {
pure fn to_str(&self) -> ~str {
let mut s = ~"";
if self.is_absolute {
@ -375,7 +375,7 @@ impl PosixPath : ToStr {
// FIXME (#3227): when default methods in traits are working, de-duplicate
// PosixPath and WindowsPath, most of their methods are common.
impl PosixPath : GenericPath {
impl GenericPath for PosixPath {
static pure fn from_str(s: &str) -> PosixPath {
let mut components = str::split_nonempty(s, |c| c == '/');
@ -526,7 +526,7 @@ impl PosixPath : GenericPath {
}
impl WindowsPath : ToStr {
impl ToStr for WindowsPath {
pure fn to_str(&self) -> ~str {
let mut s = ~"";
match self.host {
@ -545,7 +545,7 @@ impl WindowsPath : ToStr {
}
impl WindowsPath : GenericPath {
impl GenericPath for WindowsPath {
static pure fn from_str(s: &str) -> WindowsPath {
let host;

32
src/libcore/pipes.rs
View file

@ -112,7 +112,7 @@ enum State {
Terminated
}
impl State : Eq {
impl Eq for State {
pure fn eq(&self, other: &State) -> bool {
((*self) as uint) == ((*other) as uint)
}
@ -207,7 +207,7 @@ pub trait HasBuffer {
fn set_buffer(b: *libc::c_void);
}
impl<T: Owned> Packet<T>: HasBuffer {
impl<T: Owned> HasBuffer for Packet<T> {
fn set_buffer(b: *libc::c_void) {
self.header.buffer = b;
}
@ -561,7 +561,7 @@ pub pure fn peek<T: Owned, Tb: Owned>(p: &RecvPacketBuffered<T, Tb>) -> bool {
}
}
impl<T: Owned, Tb: Owned> RecvPacketBuffered<T, Tb>: Peekable<T> {
impl<T: Owned, Tb: Owned> Peekable<T> for RecvPacketBuffered<T, Tb> {
pure fn peek() -> bool {
peek(&self)
}
@ -734,7 +734,7 @@ trait Selectable {
pure fn header() -> *PacketHeader;
}
impl *PacketHeader: Selectable {
impl Selectable for *PacketHeader {
pure fn header() -> *PacketHeader { self }
}
@ -783,7 +783,7 @@ pub struct SendPacketBuffered<T, Tbuffer> {
mut buffer: Option<BufferResource<Tbuffer>>,
}
impl<T:Owned,Tbuffer:Owned> SendPacketBuffered<T,Tbuffer> : ::ops::Drop {
impl<T:Owned,Tbuffer:Owned> ::ops::Drop for SendPacketBuffered<T,Tbuffer> {
fn finalize(&self) {
//if self.p != none {
// debug!("drop send %?", option::get(self.p));
@ -852,7 +852,7 @@ pub struct RecvPacketBuffered<T, Tbuffer> {
mut buffer: Option<BufferResource<Tbuffer>>,
}
impl<T:Owned, Tbuffer:Owned> RecvPacketBuffered<T,Tbuffer> : ::ops::Drop {
impl<T:Owned, Tbuffer:Owned> ::ops::Drop for RecvPacketBuffered<T,Tbuffer> {
fn finalize(&self) {
//if self.p != none {
// debug!("drop recv %?", option::get(self.p));
@ -884,7 +884,7 @@ impl<T: Owned, Tbuffer: Owned> RecvPacketBuffered<T, Tbuffer> {
}
}
impl<T: Owned, Tbuffer: Owned> RecvPacketBuffered<T, Tbuffer> : Selectable {
impl<T: Owned, Tbuffer: Owned> Selectable for RecvPacketBuffered<T, Tbuffer> {
pure fn header() -> *PacketHeader {
match self.p {
Some(packet) => unsafe {
@ -1036,7 +1036,7 @@ pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
(Port_(Port_ { endp: Some(s) }), Chan_(Chan_{ endp: Some(c) }))
}
impl<T: Owned> Chan<T>: GenericChan<T> {
impl<T: Owned> GenericChan<T> for Chan<T> {
fn send(x: T) {
let mut endp = None;
endp <-> self.endp;
@ -1045,7 +1045,7 @@ impl<T: Owned> Chan<T>: GenericChan<T> {
}
}
impl<T: Owned> Chan<T>: GenericSmartChan<T> {
impl<T: Owned> GenericSmartChan<T> for Chan<T> {
fn try_send(x: T) -> bool {
let mut endp = None;
@ -1060,7 +1060,7 @@ impl<T: Owned> Chan<T>: GenericSmartChan<T> {
}
}
impl<T: Owned> Port<T>: GenericPort<T> {
impl<T: Owned> GenericPort<T> for Port<T> {
fn recv() -> T {
let mut endp = None;
endp <-> self.endp;
@ -1082,7 +1082,7 @@ impl<T: Owned> Port<T>: GenericPort<T> {
}
}
impl<T: Owned> Port<T>: Peekable<T> {
impl<T: Owned> Peekable<T> for Port<T> {
pure fn peek() -> bool {
unsafe {
let mut endp = None;
@ -1097,7 +1097,7 @@ impl<T: Owned> Port<T>: Peekable<T> {
}
}
impl<T: Owned> Port<T>: Selectable {
impl<T: Owned> Selectable for Port<T> {
pure fn header() -> *PacketHeader {
unsafe {
match self.endp {
@ -1132,7 +1132,7 @@ impl<T: Owned> PortSet<T> {
}
}
impl<T: Owned> PortSet<T> : GenericPort<T> {
impl<T: Owned> GenericPort<T> for PortSet<T> {
fn try_recv() -> Option<T> {
let mut result = None;
@ -1162,7 +1162,7 @@ impl<T: Owned> PortSet<T> : GenericPort<T> {
}
impl<T: Owned> PortSet<T> : Peekable<T> {
impl<T: Owned> Peekable<T> for PortSet<T> {
pure fn peek() -> bool {
// It'd be nice to use self.port.each, but that version isn't
// pure.
@ -1176,7 +1176,7 @@ impl<T: Owned> PortSet<T> : Peekable<T> {
/// A channel that can be shared between many senders.
pub type SharedChan<T> = private::Exclusive<Chan<T>>;
impl<T: Owned> SharedChan<T>: GenericChan<T> {
impl<T: Owned> GenericChan<T> for SharedChan<T> {
fn send(x: T) {
let mut xx = Some(move x);
do self.with_imm |chan| {
@ -1187,7 +1187,7 @@ impl<T: Owned> SharedChan<T>: GenericChan<T> {
}
}
impl<T: Owned> SharedChan<T>: GenericSmartChan<T> {
impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
fn try_send(x: T) -> bool {
let mut xx = Some(move x);
do self.with_imm |chan| {

4
src/libcore/private.rs
View file

@ -291,7 +291,7 @@ pub unsafe fn clone_shared_mutable_state<T: Owned>(rc: &SharedMutableState<T>)
ArcDestruct((*rc).data)
}
impl<T: Owned> SharedMutableState<T>: Clone {
impl<T: Owned> Clone for SharedMutableState<T> {
fn clone(&self) -> SharedMutableState<T> {
unsafe {
clone_shared_mutable_state(self)
@ -360,7 +360,7 @@ pub fn exclusive<T:Owned >(user_data: T) -> Exclusive<T> {
Exclusive { x: unsafe { shared_mutable_state(move data) } }
}
impl<T: Owned> Exclusive<T>: Clone {
impl<T: Owned> Clone for Exclusive<T> {
// Duplicate an exclusive ARC, as std::arc::clone.
fn clone(&self) -> Exclusive<T> {
Exclusive { x: unsafe { clone_shared_mutable_state(&self.x) } }

6
src/libcore/private/finally.rs
View file

@ -39,7 +39,7 @@ pub trait Finally<T> {
}
#[cfg(stage0)]
impl<T> &fn() -> T: Finally<T> {
impl<T> Finally<T> for &fn() -> T {
// FIXME #4518: Should not require a mode here
fn finally(&self, +dtor: &fn()) -> T {
let _d = Finallyalizer {
@ -53,7 +53,7 @@ impl<T> &fn() -> T: Finally<T> {
#[cfg(stage1)]
#[cfg(stage2)]
#[cfg(stage3)]
impl<T> &fn() -> T: Finally<T> {
impl<T> Finally<T> for &fn() -> T {
fn finally(&self, dtor: &fn()) -> T {
let _d = Finallyalizer {
dtor: dtor
@ -67,7 +67,7 @@ struct Finallyalizer {
dtor: &fn()
}
impl Finallyalizer: Drop {
impl Drop for Finallyalizer {
fn finalize(&self) {
(self.dtor)();
}

2
src/libcore/private/global.rs
View file

@ -146,7 +146,7 @@ struct GlobalState {
map: LinearMap<uint, (*c_void, ~fn())>
}
impl GlobalState: Drop {
impl Drop for GlobalState {
fn finalize(&self) {
for self.map.each_value |v| {
match v {

12
src/libcore/ptr.rs
View file

@ -194,7 +194,7 @@ pub extern {
}
/// Extension methods for immutable pointers
impl<T> *T: Ptr<T> {
impl<T> Ptr<T> for *T {
/// Returns true if the pointer is equal to the null pointer.
#[inline(always)]
pure fn is_null() -> bool { is_null(self) }
@ -209,7 +209,7 @@ impl<T> *T: Ptr<T> {
}
/// Extension methods for mutable pointers
impl<T> *mut T: Ptr<T> {
impl<T> Ptr<T> for *mut T {
/// Returns true if the pointer is equal to the null pointer.
#[inline(always)]
pure fn is_null() -> bool { is_null(self) }
@ -225,7 +225,7 @@ impl<T> *mut T: Ptr<T> {
// Equality for pointers
#[cfg(notest)]
impl<T> *const T : Eq {
impl<T> Eq for *const T {
#[inline(always)]
pure fn eq(&self, other: &*const T) -> bool {
unsafe {
@ -240,7 +240,7 @@ impl<T> *const T : Eq {
// Comparison for pointers
#[cfg(notest)]
impl<T> *const T : Ord {
impl<T> Ord for *const T {
#[inline(always)]
pure fn lt(&self, other: &*const T) -> bool {
unsafe {
@ -277,7 +277,7 @@ impl<T> *const T : Ord {
// Equality for region pointers
#[cfg(notest)]
impl<T:Eq> &const T : Eq {
impl<T:Eq> Eq for &const T {
#[inline(always)]
pure fn eq(&self, other: & &self/const T) -> bool {
return *(*self) == *(*other);
@ -290,7 +290,7 @@ impl<T:Eq> &const T : Eq {
// Comparison for region pointers
#[cfg(notest)]
impl<T:Ord> &const T : Ord {
impl<T:Ord> Ord for &const T {
#[inline(always)]
pure fn lt(&self, other: & &self/const T) -> bool {
*(*self) < *(*other)

34
src/libcore/rand.rs
View file

@ -24,91 +24,91 @@ pub trait Rand {
static fn rand(rng: rand::Rng) -> Self;
}
impl int: Rand {
impl Rand for int {
static fn rand(rng: rand::Rng) -> int {
rng.gen_int()
}
}
impl i8: Rand {
impl Rand for i8 {
static fn rand(rng: rand::Rng) -> i8 {
rng.gen_i8()
}
}
impl i16: Rand {
impl Rand for i16 {
static fn rand(rng: rand::Rng) -> i16 {
rng.gen_i16()
}
}
impl i32: Rand {
impl Rand for i32 {
static fn rand(rng: rand::Rng) -> i32 {
rng.gen_i32()
}
}
impl i64: Rand {
impl Rand for i64 {
static fn rand(rng: rand::Rng) -> i64 {
rng.gen_i64()
}
}
impl u8: Rand {
impl Rand for u8 {
static fn rand(rng: rand::Rng) -> u8 {
rng.gen_u8()
}
}
impl u16: Rand {
impl Rand for u16 {
static fn rand(rng: rand::Rng) -> u16 {
rng.gen_u16()
}
}
impl u32: Rand {
impl Rand for u32 {
static fn rand(rng: rand::Rng) -> u32 {
rng.gen_u32()
}
}
impl u64: Rand {
impl Rand for u64 {
static fn rand(rng: rand::Rng) -> u64 {
rng.gen_u64()
}
}
impl float: Rand {
impl Rand for float {
static fn rand(rng: rand::Rng) -> float {
rng.gen_float()
}
}
impl f32: Rand {
impl Rand for f32 {
static fn rand(rng: rand::Rng) -> f32 {
rng.gen_f32()
}
}
impl f64: Rand {
impl Rand for f64 {
static fn rand(rng: rand::Rng) -> f64 {
rng.gen_f64()
}
}
impl char: Rand {
impl Rand for char {
static fn rand(rng: rand::Rng) -> char {
rng.gen_char()
}
}
impl bool: Rand {
impl Rand for bool {
static fn rand(rng: rand::Rng) -> bool {
rng.gen_bool()
}
}
impl<T: Rand> Option<T>: Rand {
impl<T: Rand> Rand for Option<T> {
static fn rand(rng: rand::Rng) -> Option<T> {
if rng.gen_bool() { Some(Rand::rand(rng)) }
else { None }
@ -377,7 +377,7 @@ fn RandRes(c: *rctx) -> RandRes {
}
}
impl @RandRes: Rng {
impl Rng for @RandRes {
fn next() -> u32 {
unsafe {
return rustrt::rand_next((*self).c);
@ -418,7 +418,7 @@ struct XorShiftState {
mut w: u32,
}
impl XorShiftState: Rng {
impl Rng for XorShiftState {
fn next() -> u32 {
let x = self.x;
let mut t = x ^ (x << 11);

2
src/libcore/reflect.rs
View file

@ -72,7 +72,7 @@ impl<V: TyVisitor MovePtr> MovePtrAdaptor<V> {
}
/// Abstract type-directed pointer-movement using the MovePtr trait
impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
impl<V: TyVisitor MovePtr> TyVisitor for MovePtrAdaptor<V> {
fn visit_bot(&self) -> bool {
self.align_to::<()>();
if ! self.inner.visit_bot() { return false; }

38
src/libcore/repr.rs
View file

@ -46,7 +46,7 @@ trait EscapedCharWriter {
fn write_escaped_char(ch: char);
}
impl Writer : EscapedCharWriter {
impl EscapedCharWriter for Writer {
fn write_escaped_char(ch: char) {
match ch {
'\t' => self.write_str("\\t"),
@ -71,64 +71,64 @@ trait Repr {
fn write_repr(writer: @Writer);
}
impl () : Repr {
impl Repr for () {
fn write_repr(writer: @Writer) { writer.write_str("()"); }
}
impl bool : Repr {
impl Repr for bool {
fn write_repr(writer: @Writer) {
writer.write_str(if self { "true" } else { "false" })
}
}
impl int : Repr {
impl Repr for int {
fn write_repr(writer: @Writer) { writer.write_int(self); }
}
impl i8 : Repr {
impl Repr for i8 {
fn write_repr(writer: @Writer) { writer.write_int(self as int); }
}
impl i16 : Repr {
impl Repr for i16 {
fn write_repr(writer: @Writer) { writer.write_int(self as int); }
}
impl i32 : Repr {
impl Repr for i32 {
fn write_repr(writer: @Writer) { writer.write_int(self as int); }
}
impl i64 : Repr {
impl Repr for i64 {
// FIXME #4424: This can lose precision.
fn write_repr(writer: @Writer) { writer.write_int(self as int); }
}
impl uint : Repr {
impl Repr for uint {
fn write_repr(writer: @Writer) { writer.write_uint(self); }
}
impl u8 : Repr {
impl Repr for u8 {
fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
}
impl u16 : Repr {
impl Repr for u16 {
fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
}
impl u32 : Repr {
impl Repr for u32 {
fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
}
impl u64 : Repr {
impl Repr for u64 {
// FIXME #4424: This can lose precision.
fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
}
impl float : Repr {
impl Repr for float {
// FIXME #4423: This mallocs.
fn write_repr(writer: @Writer) { writer.write_str(self.to_str()); }
}
impl f32 : Repr {
impl Repr for f32 {
// FIXME #4423 This mallocs.
fn write_repr(writer: @Writer) { writer.write_str(self.to_str()); }
}
impl f64 : Repr {
impl Repr for f64 {
// FIXME #4423: This mallocs.
fn write_repr(writer: @Writer) { writer.write_str(self.to_str()); }
}
impl char : Repr {
impl Repr for char {
fn write_repr(writer: @Writer) { writer.write_char(self); }
}
@ -154,7 +154,7 @@ pub fn ReprVisitor(ptr: *c_void, writer: @Writer) -> ReprVisitor {
writer: writer }
}
impl ReprVisitor : MovePtr {
impl MovePtr for ReprVisitor {
#[inline(always)]
fn move_ptr(adjustment: fn(*c_void) -> *c_void) {
self.ptr = adjustment(self.ptr);
@ -262,7 +262,7 @@ impl ReprVisitor {
}
impl ReprVisitor : TyVisitor {
impl TyVisitor for ReprVisitor {
fn visit_bot(&self) -> bool {
self.writer.write_str("!");
true

2
src/libcore/run.rs
View file

@ -262,7 +262,7 @@ pub fn start_program(prog: &str, args: &[~str]) -> Program {
}
}
impl ProgRes: Program {
impl Program for ProgRes {
fn get_id(&mut self) -> pid_t { return self.r.pid; }
fn input(&mut self) -> io::Writer {
io::fd_writer(self.r.in_fd, false)

18
src/libcore/str.rs
View file

@ -771,7 +771,7 @@ pure fn gt(a: &str, b: &str) -> bool {
}
#[cfg(notest)]
impl &str : Eq {
impl Eq for &str {
#[inline(always)]
pure fn eq(&self, other: & &self/str) -> bool {
eq_slice((*self), (*other))
@ -781,7 +781,7 @@ impl &str : Eq {
}
#[cfg(notest)]
impl ~str : Eq {
impl Eq for ~str {
#[inline(always)]
pure fn eq(&self, other: &~str) -> bool {
eq_slice((*self), (*other))
@ -791,7 +791,7 @@ impl ~str : Eq {
}
#[cfg(notest)]
impl @str : Eq {
impl Eq for @str {
#[inline(always)]
pure fn eq(&self, other: &@str) -> bool {
eq_slice((*self), (*other))
@ -801,7 +801,7 @@ impl @str : Eq {
}
#[cfg(notest)]
impl ~str : Ord {
impl Ord for ~str {
#[inline(always)]
pure fn lt(&self, other: &~str) -> bool { lt((*self), (*other)) }
#[inline(always)]
@ -813,7 +813,7 @@ impl ~str : Ord {
}
#[cfg(notest)]
impl &str : Ord {
impl Ord for &str {
#[inline(always)]
pure fn lt(&self, other: & &self/str) -> bool { lt((*self), (*other)) }
#[inline(always)]
@ -825,7 +825,7 @@ impl &str : Ord {
}
#[cfg(notest)]
impl @str : Ord {
impl Ord for @str {
#[inline(always)]
pure fn lt(&self, other: &@str) -> bool { lt((*self), (*other)) }
#[inline(always)]
@ -2134,7 +2134,7 @@ pub trait Trimmable {
}
/// Extension methods for strings
impl ~str: Trimmable {
impl Trimmable for ~str {
/// Returns a string with leading and trailing whitespace removed
#[inline]
pure fn trim() -> ~str { trim(self) }
@ -2151,7 +2151,7 @@ pub mod traits {
use ops::Add;
use str::append;
impl ~str : Add<&str,~str> {
impl Add<&str,~str> for ~str {
#[inline(always)]
pure fn add(&self, rhs: & &self/str) -> ~str {
append(copy *self, (*rhs))
@ -2195,7 +2195,7 @@ pub trait StrSlice {
}
/// Extension methods for strings
impl &str: StrSlice {
impl StrSlice for &str {
/**
* Return true if a predicate matches all characters or if the string
* contains no characters

4
src/libcore/task/local_data_priv.rs
View file

@ -26,9 +26,9 @@ use rt::rust_task;
type rust_task = libc::c_void;
pub trait LocalData { }
impl<T: Durable> @T: LocalData { }
impl<T: Durable> LocalData for @T { }
impl LocalData: Eq {
impl Eq for LocalData {
pure fn eq(&self, other: &@LocalData) -> bool {
unsafe {
let ptr_a: (uint, uint) = cast::reinterpret_cast(&(*self));

2
src/libcore/task/mod.rs
View file

@ -84,7 +84,7 @@ pub enum TaskResult {
Failure,
}
impl TaskResult : Eq {
impl Eq for TaskResult {
pure fn eq(&self, other: &TaskResult) -> bool {
match ((*self), (*other)) {
(Success, Success) | (Failure, Failure) => true,

50
src/libcore/to_bytes.rs
View file

@ -46,7 +46,7 @@ pub trait IterBytes {
pure fn iter_bytes(&self, lsb0: bool, f: Cb);
}
impl bool: IterBytes {
impl IterBytes for bool {
#[inline(always)]
pure fn iter_bytes(&self, _lsb0: bool, f: Cb) {
f([
@ -55,7 +55,7 @@ impl bool: IterBytes {
}
}
impl u8: IterBytes {
impl IterBytes for u8 {
#[inline(always)]
pure fn iter_bytes(&self, _lsb0: bool, f: Cb) {
f([
@ -64,7 +64,7 @@ impl u8: IterBytes {
}
}
impl u16: IterBytes {
impl IterBytes for u16 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
if lsb0 {
@ -81,7 +81,7 @@ impl u16: IterBytes {
}
}
impl u32: IterBytes {
impl IterBytes for u32 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
if lsb0 {
@ -102,7 +102,7 @@ impl u32: IterBytes {
}
}
impl u64: IterBytes {
impl IterBytes for u64 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
if lsb0 {
@ -131,35 +131,35 @@ impl u64: IterBytes {
}
}
impl i8: IterBytes {
impl IterBytes for i8 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u8).iter_bytes(lsb0, f)
}
}
impl i16: IterBytes {
impl IterBytes for i16 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u16).iter_bytes(lsb0, f)
}
}
impl i32: IterBytes {
impl IterBytes for i32 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u32).iter_bytes(lsb0, f)
}
}
impl i64: IterBytes {
impl IterBytes for i64 {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u64).iter_bytes(lsb0, f)
}
}
impl char: IterBytes {
impl IterBytes for char {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as u32).iter_bytes(lsb0, f)
@ -190,14 +190,14 @@ pub mod x64 {
}
}
impl int: IterBytes {
impl IterBytes for int {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as uint).iter_bytes(lsb0, f)
}
}
impl<A: IterBytes> &[A]: IterBytes {
impl<A: IterBytes> IterBytes for &[A] {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
for (*self).each |elt| {
@ -208,7 +208,7 @@ impl<A: IterBytes> &[A]: IterBytes {
}
}
impl<A: IterBytes, B: IterBytes> (A,B): IterBytes {
impl<A: IterBytes, B: IterBytes> IterBytes for (A,B) {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
match *self {
@ -219,7 +219,7 @@ impl<A: IterBytes, B: IterBytes> (A,B): IterBytes {
}
}
impl<A: IterBytes, B: IterBytes, C: IterBytes> (A,B,C): IterBytes {
impl<A: IterBytes, B: IterBytes, C: IterBytes> IterBytes for (A,B,C) {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
match *self {
@ -235,14 +235,14 @@ pure fn borrow<A>(a: &x/[A]) -> &x/[A] {
a
}
impl<A: IterBytes> ~[A]: IterBytes {
impl<A: IterBytes> IterBytes for ~[A] {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
borrow(*self).iter_bytes(lsb0, f)
}
}
impl<A: IterBytes> @[A]: IterBytes {
impl<A: IterBytes> IterBytes for @[A] {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
borrow(*self).iter_bytes(lsb0, f)
@ -352,7 +352,7 @@ pub pure fn iter_bytes_7<A: IterBytes,
g.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
}
impl &str: IterBytes {
impl IterBytes for &str {
#[inline(always)]
pure fn iter_bytes(&self, _lsb0: bool, f: Cb) {
do str::byte_slice(*self) |bytes| {
@ -361,7 +361,7 @@ impl &str: IterBytes {
}
}
impl ~str: IterBytes {
impl IterBytes for ~str {
#[inline(always)]
pure fn iter_bytes(&self, _lsb0: bool, f: Cb) {
do str::byte_slice(*self) |bytes| {
@ -370,7 +370,7 @@ impl ~str: IterBytes {
}
}
impl @str: IterBytes {
impl IterBytes for @str {
#[inline(always)]
pure fn iter_bytes(&self, _lsb0: bool, f: Cb) {
do str::byte_slice(*self) |bytes| {
@ -379,7 +379,7 @@ impl @str: IterBytes {
}
}
impl<A: IterBytes> Option<A>: IterBytes {
impl<A: IterBytes> IterBytes for Option<A> {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
match *self {
@ -389,21 +389,21 @@ impl<A: IterBytes> Option<A>: IterBytes {
}
}
impl<A: IterBytes> &A: IterBytes {
impl<A: IterBytes> IterBytes for &A {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(**self).iter_bytes(lsb0, f);
}
}
impl<A: IterBytes> @A: IterBytes {
impl<A: IterBytes> IterBytes for @A {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(**self).iter_bytes(lsb0, f);
}
}
impl<A: IterBytes> ~A: IterBytes {
impl<A: IterBytes> IterBytes for ~A {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(**self).iter_bytes(lsb0, f);
@ -412,7 +412,7 @@ impl<A: IterBytes> ~A: IterBytes {
// NB: raw-pointer IterBytes does _not_ dereference
// to the target; it just gives you the pointer-bytes.
impl<A> *const A: IterBytes {
impl<A> IterBytes for *const A {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
(*self as uint).iter_bytes(lsb0, f);
@ -424,7 +424,7 @@ trait ToBytes {
fn to_bytes(&self, lsb0: bool) -> ~[u8];
}
impl<A: IterBytes> A: ToBytes {
impl<A: IterBytes> ToBytes for A {
fn to_bytes(&self, lsb0: bool) -> ~[u8] {
do io::with_bytes_writer |wr| {
for self.iter_bytes(lsb0) |bytes| {

20
src/libcore/to_str.rs
View file

@ -22,28 +22,28 @@ pub trait ToStr {
pure fn to_str(&self) -> ~str;
}
impl bool: ToStr {
impl ToStr for bool {
#[inline(always)]
pure fn to_str(&self) -> ~str { ::bool::to_str(*self) }
}
impl (): ToStr {
impl ToStr for () {
#[inline(always)]
pure fn to_str(&self) -> ~str { ~"()" }
}
impl ~str: ToStr {
impl ToStr for ~str {
#[inline(always)]
pure fn to_str(&self) -> ~str { copy *self }
}
impl &str: ToStr {
impl ToStr for &str {
#[inline(always)]
pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
}
impl @str: ToStr {
impl ToStr for @str {
#[inline(always)]
pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
}
impl<A: ToStr, B: ToStr> (A, B): ToStr {
impl<A: ToStr, B: ToStr> ToStr for (A, B) {
#[inline(always)]
pure fn to_str(&self) -> ~str {
// FIXME(#4760): this causes an llvm assertion
@ -55,7 +55,7 @@ impl<A: ToStr, B: ToStr> (A, B): ToStr {
}
}
}
impl<A: ToStr, B: ToStr, C: ToStr> (A, B, C): ToStr {
impl<A: ToStr, B: ToStr, C: ToStr> ToStr for (A, B, C) {
#[inline(always)]
pure fn to_str(&self) -> ~str {
// FIXME(#4760): this causes an llvm assertion
@ -72,7 +72,7 @@ impl<A: ToStr, B: ToStr, C: ToStr> (A, B, C): ToStr {
}
}
impl<A: ToStr> ~[A]: ToStr {
impl<A: ToStr> ToStr for ~[A] {
#[inline(always)]
pure fn to_str(&self) -> ~str {
unsafe {
@ -92,11 +92,11 @@ impl<A: ToStr> ~[A]: ToStr {
}
}
impl<A: ToStr> @A: ToStr {
impl<A: ToStr> ToStr for @A {
#[inline(always)]
pure fn to_str(&self) -> ~str { ~"@" + (**self).to_str() }
}
impl<A: ToStr> ~A: ToStr {
impl<A: ToStr> ToStr for ~A {
#[inline(always)]
pure fn to_str(&self) -> ~str { ~"~" + (**self).to_str() }
}

16
src/libcore/tuple.rs
View file

@ -20,7 +20,7 @@ pub trait CopyableTuple<T, U> {
pure fn swap() -> (U, T);
}
impl<T: Copy, U: Copy> (T, U): CopyableTuple<T, U> {
impl<T: Copy, U: Copy> CopyableTuple<T, U> for (T, U) {
/// Return the first element of self
#[inline(always)]
@ -50,7 +50,7 @@ pub trait ImmutableTuple<T, U> {
pure fn second_ref(&self) -> &self/U;
}
impl<T, U> (T, U): ImmutableTuple<T, U> {
impl<T, U> ImmutableTuple<T, U> for (T, U) {
#[inline(always)]
pure fn first_ref(&self) -> &self/T {
match *self {
@ -70,7 +70,7 @@ pub trait ExtendedTupleOps<A,B> {
fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C];
}
impl<A: Copy, B: Copy> (&[A], &[B]): ExtendedTupleOps<A,B> {
impl<A: Copy, B: Copy> ExtendedTupleOps<A,B> for (&[A], &[B]) {
#[inline(always)]
fn zip(&self) -> ~[(A, B)] {
match *self {
@ -90,7 +90,7 @@ impl<A: Copy, B: Copy> (&[A], &[B]): ExtendedTupleOps<A,B> {
}
}
impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
impl<A: Copy, B: Copy> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
#[inline(always)]
fn zip(&self) -> ~[(A, B)] {
@ -112,7 +112,7 @@ impl<A: Copy, B: Copy> (~[A], ~[B]): ExtendedTupleOps<A,B> {
}
#[cfg(notest)]
impl<A: Eq, B: Eq> (A, B) : Eq {
impl<A: Eq, B: Eq> Eq for (A, B) {
#[inline(always)]
pure fn eq(&self, other: &(A, B)) -> bool {
match (*self) {
@ -128,7 +128,7 @@ impl<A: Eq, B: Eq> (A, B) : Eq {
}
#[cfg(notest)]
impl<A: Ord, B: Ord> (A, B) : Ord {
impl<A: Ord, B: Ord> Ord for (A, B) {
#[inline(always)]
pure fn lt(&self, other: &(A, B)) -> bool {
match (*self) {
@ -153,7 +153,7 @@ impl<A: Ord, B: Ord> (A, B) : Ord {
}
#[cfg(notest)]
impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
impl<A: Eq, B: Eq, C: Eq> Eq for (A, B, C) {
#[inline(always)]
pure fn eq(&self, other: &(A, B, C)) -> bool {
match (*self) {
@ -170,7 +170,7 @@ impl<A: Eq, B: Eq, C: Eq> (A, B, C) : Eq {
}
#[cfg(notest)]
impl<A: Ord, B: Ord, C: Ord> (A, B, C) : Ord {
impl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C) {
#[inline(always)]
pure fn lt(&self, other: &(A, B, C)) -> bool {
match (*self) {

68
src/libcore/vec.rs
View file

@ -1559,7 +1559,7 @@ pure fn eq<T: Eq>(a: &[T], b: &[T]) -> bool {
}
#[cfg(notest)]
impl<T: Eq> &[T] : Eq {
impl<T: Eq> Eq for &[T] {
#[inline(always)]
pure fn eq(&self, other: & &self/[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
@ -1568,7 +1568,7 @@ impl<T: Eq> &[T] : Eq {
#[cfg(notest)]
impl<T: Eq> ~[T] : Eq {
impl<T: Eq> Eq for ~[T] {
#[inline(always)]
pure fn eq(&self, other: &~[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
@ -1576,7 +1576,7 @@ impl<T: Eq> ~[T] : Eq {
}
#[cfg(notest)]
impl<T: Eq> @[T] : Eq {
impl<T: Eq> Eq for @[T] {
#[inline(always)]
pure fn eq(&self, other: &@[T]) -> bool { eq((*self), (*other)) }
#[inline(always)]
@ -1605,7 +1605,7 @@ pure fn ge<T: Ord>(a: &[T], b: &[T]) -> bool { !lt(a, b) }
pure fn gt<T: Ord>(a: &[T], b: &[T]) -> bool { lt(b, a) }
#[cfg(notest)]
impl<T: Ord> &[T] : Ord {
impl<T: Ord> Ord for &[T] {
#[inline(always)]
pure fn lt(&self, other: & &self/[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
@ -1617,7 +1617,7 @@ impl<T: Ord> &[T] : Ord {
}
#[cfg(notest)]
impl<T: Ord> ~[T] : Ord {
impl<T: Ord> Ord for ~[T] {
#[inline(always)]
pure fn lt(&self, other: &~[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
@ -1629,7 +1629,7 @@ impl<T: Ord> ~[T] : Ord {
}
#[cfg(notest)]
impl<T: Ord> @[T] : Ord {
impl<T: Ord> Ord for @[T] {
#[inline(always)]
pure fn lt(&self, other: &@[T]) -> bool { lt((*self), (*other)) }
#[inline(always)]
@ -1646,7 +1646,7 @@ pub mod traits {
use ops::Add;
use vec::append;
impl<T: Copy> ~[T] : Add<&[const T],~[T]> {
impl<T: Copy> Add<&[const T],~[T]> for ~[T] {
#[inline(always)]
pure fn add(&self, rhs: & &self/[const T]) -> ~[T] {
append(copy *self, (*rhs))
@ -1654,7 +1654,7 @@ pub mod traits {
}
}
impl<T> &[const T]: Container {
impl<T> Container for &[const T] {
/// Returns true if a vector contains no elements
#[inline]
pure fn is_empty(&self) -> bool { is_empty(*self) }
@ -1673,7 +1673,7 @@ pub trait CopyableVector<T> {
}
/// Extension methods for vectors
impl<T: Copy> &[const T]: CopyableVector<T> {
impl<T: Copy> CopyableVector<T> for &[const T] {
/// Returns the first element of a vector
#[inline]
pure fn head(&self) -> T { head(*self) }
@ -1709,7 +1709,7 @@ pub trait ImmutableVector<T> {
}
/// Extension methods for vectors
impl<T> &[T]: ImmutableVector<T> {
impl<T> ImmutableVector<T> for &[T] {
/// Return a slice that points into another slice.
#[inline]
pure fn view(&self, start: uint, end: uint) -> &self/[T] {
@ -1780,7 +1780,7 @@ pub trait ImmutableEqVector<T: Eq> {
pure fn rposition_elem(&self, t: &T) -> Option<uint>;
}
impl<T: Eq> &[T]: ImmutableEqVector<T> {
impl<T: Eq> ImmutableEqVector<T> for &[T] {
/**
* Find the first index matching some predicate
*
@ -1825,7 +1825,7 @@ pub trait ImmutableCopyableVector<T> {
}
/// Extension methods for vectors
impl<T: Copy> &[T]: ImmutableCopyableVector<T> {
impl<T: Copy> ImmutableCopyableVector<T> for &[T] {
/**
* Construct a new vector from the elements of a vector for which some
* predicate holds.
@ -1876,7 +1876,7 @@ pub trait OwnedVector<T> {
fn partition(self, f: pure fn(&T) -> bool) -> (~[T], ~[T]);
}
impl<T> ~[T]: OwnedVector<T> {
impl<T> OwnedVector<T> for ~[T] {
#[inline]
fn push(&mut self, t: T) {
push(self, t);
@ -1947,7 +1947,7 @@ impl<T> ~[T]: OwnedVector<T> {
}
}
impl<T> ~[T]: Mutable {
impl<T> Mutable for ~[T] {
/// Clear the vector, removing all values.
fn clear(&mut self) { self.truncate(0) }
}
@ -1959,7 +1959,7 @@ pub trait OwnedCopyableVector<T: Copy> {
fn grow_set(&mut self, index: uint, initval: &T, val: T);
}
impl<T: Copy> ~[T]: OwnedCopyableVector<T> {
impl<T: Copy> OwnedCopyableVector<T> for ~[T] {
#[inline]
fn push_all(&mut self, rhs: &[const T]) {
push_all(self, rhs);
@ -1985,7 +1985,7 @@ trait OwnedEqVector<T: Eq> {
fn dedup(&mut self);
}
impl<T: Eq> ~[T]: OwnedEqVector<T> {
impl<T: Eq> OwnedEqVector<T> for ~[T] {
#[inline]
fn dedup(&mut self) {
dedup(self)
@ -2218,7 +2218,7 @@ pub mod bytes {
// This cannot be used with iter-trait.rs because of the region pointer
// required in the slice.
impl<A> &[A]: iter::BaseIter<A> {
impl<A> iter::BaseIter<A> for &[A] {
pub pure fn each(&self, blk: fn(v: &A) -> bool) {
// FIXME(#2263)---should be able to call each(self, blk)
for each(*self) |e| {
@ -2231,7 +2231,7 @@ impl<A> &[A]: iter::BaseIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A> ~[A]: iter::BaseIter<A> {
impl<A> iter::BaseIter<A> for ~[A] {
pub pure fn each(&self, blk: fn(v: &A) -> bool) {
// FIXME(#2263)---should be able to call each(self, blk)
for each(*self) |e| {
@ -2244,7 +2244,7 @@ impl<A> ~[A]: iter::BaseIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A> @[A]: iter::BaseIter<A> {
impl<A> iter::BaseIter<A> for @[A] {
pub pure fn each(&self, blk: fn(v: &A) -> bool) {
// FIXME(#2263)---should be able to call each(self, blk)
for each(*self) |e| {
@ -2256,7 +2256,7 @@ impl<A> @[A]: iter::BaseIter<A> {
pure fn size_hint(&self) -> Option<uint> { Some(len(*self)) }
}
impl<A> &[A]: iter::ExtendedIter<A> {
impl<A> iter::ExtendedIter<A> for &[A] {
pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
iter::eachi(self, blk)
}
@ -2282,7 +2282,7 @@ impl<A> &[A]: iter::ExtendedIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A> ~[A]: iter::ExtendedIter<A> {
impl<A> iter::ExtendedIter<A> for ~[A] {
pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
iter::eachi(self, blk)
}
@ -2308,7 +2308,7 @@ impl<A> ~[A]: iter::ExtendedIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A> @[A]: iter::ExtendedIter<A> {
impl<A> iter::ExtendedIter<A> for @[A] {
pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
iter::eachi(self, blk)
}
@ -2333,24 +2333,24 @@ impl<A> @[A]: iter::ExtendedIter<A> {
}
}
impl<A: Eq> &[A]: iter::EqIter<A> {
impl<A: Eq> iter::EqIter<A> for &[A] {
pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
}
// FIXME(#4148): This should be redundant
impl<A: Eq> ~[A]: iter::EqIter<A> {
impl<A: Eq> iter::EqIter<A> for ~[A] {
pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
}
// FIXME(#4148): This should be redundant
impl<A: Eq> @[A]: iter::EqIter<A> {
impl<A: Eq> iter::EqIter<A> for @[A] {
pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
}
impl<A: Copy> &[A]: iter::CopyableIter<A> {
impl<A: Copy> iter::CopyableIter<A> for &[A] {
pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
iter::filter_to_vec(self, pred)
}
@ -2361,7 +2361,7 @@ impl<A: Copy> &[A]: iter::CopyableIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A: Copy> ~[A]: iter::CopyableIter<A> {
impl<A: Copy> iter::CopyableIter<A> for ~[A] {
pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
iter::filter_to_vec(self, pred)
}
@ -2372,7 +2372,7 @@ impl<A: Copy> ~[A]: iter::CopyableIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A: Copy> @[A]: iter::CopyableIter<A> {
impl<A: Copy> iter::CopyableIter<A> for @[A] {
pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
iter::filter_to_vec(self, pred)
}
@ -2382,24 +2382,24 @@ impl<A: Copy> @[A]: iter::CopyableIter<A> {
}
}
impl<A: Copy Ord> &[A]: iter::CopyableOrderedIter<A> {
impl<A: Copy Ord> iter::CopyableOrderedIter<A> for &[A] {
pure fn min(&self) -> A { iter::min(self) }
pure fn max(&self) -> A { iter::max(self) }
}
// FIXME(#4148): This should be redundant
impl<A: Copy Ord> ~[A]: iter::CopyableOrderedIter<A> {
impl<A: Copy Ord> iter::CopyableOrderedIter<A> for ~[A] {
pure fn min(&self) -> A { iter::min(self) }
pure fn max(&self) -> A { iter::max(self) }
}
// FIXME(#4148): This should be redundant
impl<A: Copy Ord> @[A]: iter::CopyableOrderedIter<A> {
impl<A: Copy Ord> iter::CopyableOrderedIter<A> for @[A] {
pure fn min(&self) -> A { iter::min(self) }
pure fn max(&self) -> A { iter::max(self) }
}
impl<A:Copy> &[A] : iter::CopyableNonstrictIter<A> {
impl<A:Copy> iter::CopyableNonstrictIter<A> for &[A] {
pure fn each_val(&const self, f: fn(A) -> bool) {
let mut i = 0;
while i < self.len() {
@ -2410,7 +2410,7 @@ impl<A:Copy> &[A] : iter::CopyableNonstrictIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A:Copy> ~[A] : iter::CopyableNonstrictIter<A> {
impl<A:Copy> iter::CopyableNonstrictIter<A> for ~[A] {
pure fn each_val(&const self, f: fn(A) -> bool) {
let mut i = 0;
while i < self.len() {
@ -2421,7 +2421,7 @@ impl<A:Copy> ~[A] : iter::CopyableNonstrictIter<A> {
}
// FIXME(#4148): This should be redundant
impl<A:Copy> @[A] : iter::CopyableNonstrictIter<A> {
impl<A:Copy> iter::CopyableNonstrictIter<A> for @[A] {
pure fn each_val(&const self, f: fn(A) -> bool) {
let mut i = 0;
while i < self.len() {

2
src/librustc/metadata/decoder.rs
View file

@ -120,7 +120,7 @@ enum Family {
InheritedField // N
}
impl Family : cmp::Eq {
impl cmp::Eq for Family {
pure fn eq(&self, other: &Family) -> bool {
((*self) as uint) == ((*other) as uint)
}

2
src/librustc/metadata/filesearch.rs
View file

@ -41,7 +41,7 @@ pub fn mk_filesearch(maybe_sysroot: Option<Path>,
type filesearch_impl = {sysroot: Path,
addl_lib_search_paths: ~[Path],
target_triple: ~str};
impl filesearch_impl: FileSearch {
impl FileSearch for filesearch_impl {
fn sysroot() -> Path { /*bad*/copy self.sysroot }
fn lib_search_paths() -> ~[Path] {
let mut paths = /*bad*/copy self.addl_lib_search_paths;

46
src/librustc/middle/astencode.rs
View file

@ -224,19 +224,19 @@ impl extended_decode_ctxt {
}
}
impl ast::def_id: tr_intern {
impl tr_intern for ast::def_id {
fn tr_intern(xcx: extended_decode_ctxt) -> ast::def_id {
xcx.tr_intern_def_id(self)
}
}
impl ast::def_id: tr {
impl tr for ast::def_id {
fn tr(xcx: extended_decode_ctxt) -> ast::def_id {
xcx.tr_def_id(self)
}
}
impl span: tr {
impl tr for span {
fn tr(xcx: extended_decode_ctxt) -> span {
xcx.tr_span(self)
}
@ -246,7 +246,7 @@ trait def_id_encoder_helpers {
fn emit_def_id(did: ast::def_id);
}
impl<S: serialize::Encoder> S: def_id_encoder_helpers {
impl<S: serialize::Encoder> def_id_encoder_helpers for S {
fn emit_def_id(did: ast::def_id) {
did.encode(&self)
}
@ -256,7 +256,7 @@ trait def_id_decoder_helpers {
fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id;
}
impl<D: serialize::Decoder> D: def_id_decoder_helpers {
impl<D: serialize::Decoder> def_id_decoder_helpers for D {
fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id {
let did: ast::def_id = Decodable::decode(&self);
@ -402,7 +402,7 @@ fn decode_def(xcx: extended_decode_ctxt, doc: ebml::Doc) -> ast::def {
def.tr(xcx)
}
impl ast::def: tr {
impl tr for ast::def {
fn tr(xcx: extended_decode_ctxt) -> ast::def {
match self {
ast::def_fn(did, p) => { ast::def_fn(did.tr(xcx), p) }
@ -447,7 +447,7 @@ impl ast::def: tr {
// ______________________________________________________________________
// Encoding and decoding of adjustment information
impl ty::AutoAdjustment: tr {
impl tr for ty::AutoAdjustment {
fn tr(xcx: extended_decode_ctxt) -> ty::AutoAdjustment {
ty::AutoAdjustment {
autoderefs: self.autoderefs,
@ -456,7 +456,7 @@ impl ty::AutoAdjustment: tr {
}
}
impl ty::AutoRef: tr {
impl tr for ty::AutoRef {
fn tr(xcx: extended_decode_ctxt) -> ty::AutoRef {
ty::AutoRef {
kind: self.kind,
@ -466,7 +466,7 @@ impl ty::AutoRef: tr {
}
}
impl ty::Region: tr {
impl tr for ty::Region {
fn tr(xcx: extended_decode_ctxt) -> ty::Region {
match self {
ty::re_bound(br) => ty::re_bound(br.tr(xcx)),
@ -477,7 +477,7 @@ impl ty::Region: tr {
}
}
impl ty::bound_region: tr {
impl tr for ty::bound_region {
fn tr(xcx: extended_decode_ctxt) -> ty::bound_region {
match self {
ty::br_anon(_) | ty::br_named(_) | ty::br_self |
@ -499,14 +499,14 @@ trait ebml_decoder_helper {
fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry;
}
impl reader::Decoder: ebml_decoder_helper {
impl ebml_decoder_helper for reader::Decoder {
fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry {
let fv: freevar_entry = Decodable::decode(&self);
fv.tr(xcx)
}
}
impl freevar_entry: tr {
impl tr for freevar_entry {
fn tr(xcx: extended_decode_ctxt) -> freevar_entry {
freevar_entry {
def: self.def.tr(xcx),
@ -522,14 +522,14 @@ trait capture_var_helper {
fn read_capture_var(xcx: extended_decode_ctxt) -> moves::CaptureVar;
}
impl reader::Decoder : capture_var_helper {
impl capture_var_helper for reader::Decoder {
fn read_capture_var(xcx: extended_decode_ctxt) -> moves::CaptureVar {
let cvar: moves::CaptureVar = Decodable::decode(&self);
cvar.tr(xcx)
}
}
impl moves::CaptureVar : tr {
impl tr for moves::CaptureVar {
fn tr(xcx: extended_decode_ctxt) -> moves::CaptureVar {
moves::CaptureVar {
def: self.def.tr(xcx),
@ -562,7 +562,7 @@ fn encode_method_map_entry(ecx: @e::encode_ctxt,
}
}
impl reader::Decoder: read_method_map_entry_helper {
impl read_method_map_entry_helper for reader::Decoder {
fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry {
do self.read_rec {
method_map_entry {
@ -583,7 +583,7 @@ impl reader::Decoder: read_method_map_entry_helper {
}
}
impl method_origin: tr {
impl tr for method_origin {
fn tr(xcx: extended_decode_ctxt) -> method_origin {
match self {
typeck::method_static(did) => {
@ -673,7 +673,7 @@ trait vtable_decoder_helpers {
fn read_vtable_origin(xcx: extended_decode_ctxt) -> typeck::vtable_origin;
}
impl reader::Decoder: vtable_decoder_helpers {
impl vtable_decoder_helpers for reader::Decoder {
fn read_vtable_res(xcx: extended_decode_ctxt) -> typeck::vtable_res {
@self.read_to_vec(|| self.read_vtable_origin(xcx) )
}
@ -731,7 +731,7 @@ trait get_ty_str_ctxt {
fn ty_str_ctxt() -> @tyencode::ctxt;
}
impl @e::encode_ctxt: get_ty_str_ctxt {
impl get_ty_str_ctxt for @e::encode_ctxt {
fn ty_str_ctxt() -> @tyencode::ctxt {
@tyencode::ctxt {diag: self.tcx.sess.diagnostic(),
ds: e::def_to_str,
@ -750,7 +750,7 @@ trait ebml_writer_helpers {
fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty);
}
impl writer::Encoder: ebml_writer_helpers {
impl ebml_writer_helpers for writer::Encoder {
fn emit_ty(ecx: @e::encode_ctxt, ty: ty::t) {
do self.emit_opaque {
e::write_type(ecx, self, ty)
@ -803,7 +803,7 @@ trait write_tag_and_id {
fn id(id: ast::node_id);
}
impl writer::Encoder: write_tag_and_id {
impl write_tag_and_id for writer::Encoder {
fn tag(tag_id: c::astencode_tag, f: fn()) {
do self.wr_tag(tag_id as uint) { f() }
}
@ -981,7 +981,7 @@ trait doc_decoder_helpers {
fn opt_child(tag: c::astencode_tag) -> Option<ebml::Doc>;
}
impl ebml::Doc: doc_decoder_helpers {
impl doc_decoder_helpers for ebml::Doc {
fn as_int() -> int { reader::doc_as_u64(self) as int }
fn opt_child(tag: c::astencode_tag) -> Option<ebml::Doc> {
reader::maybe_get_doc(self, tag as uint)
@ -1000,7 +1000,7 @@ trait ebml_decoder_decoder_helpers {
did: ast::def_id) -> ast::def_id;
}
impl reader::Decoder: ebml_decoder_decoder_helpers {
impl ebml_decoder_decoder_helpers for reader::Decoder {
fn read_arg(xcx: extended_decode_ctxt) -> ty::arg {
do self.read_opaque |doc| {
tydecode::parse_arg_data(
@ -1198,7 +1198,7 @@ trait fake_ext_ctxt {
type fake_session = parse::parse_sess;
#[cfg(test)]
impl fake_session: fake_ext_ctxt {
impl fake_ext_ctxt for fake_session {
fn cfg() -> ast::crate_cfg { ~[] }
fn parse_sess() -> parse::parse_sess { self }
fn call_site() -> span {

2
src/librustc/middle/lint.rs
View file

@ -106,7 +106,7 @@ pub enum level {
allow, warn, deny, forbid
}
impl level : cmp::Eq {
impl cmp::Eq for level {
pure fn eq(&self, other: &level) -> bool {
((*self) as uint) == ((*other) as uint)
}

10
src/librustc/middle/liveness.rs
View file

@ -141,12 +141,12 @@ pub type last_use_map = HashMap<node_id, @DVec<node_id>>;
enum Variable = uint;
enum LiveNode = uint;
impl Variable : cmp::Eq {
impl cmp::Eq for Variable {
pure fn eq(&self, other: &Variable) -> bool { *(*self) == *(*other) }
pure fn ne(&self, other: &Variable) -> bool { *(*self) != *(*other) }
}
impl LiveNode : cmp::Eq {
impl cmp::Eq for LiveNode {
pure fn eq(&self, other: &LiveNode) -> bool { *(*self) == *(*other) }
pure fn ne(&self, other: &LiveNode) -> bool { *(*self) != *(*other) }
}
@ -158,7 +158,7 @@ enum LiveNodeKind {
ExitNode
}
impl LiveNodeKind : cmp::Eq {
impl cmp::Eq for LiveNodeKind {
pure fn eq(&self, other: &LiveNodeKind) -> bool {
match (*self) {
FreeVarNode(e0a) => {
@ -224,11 +224,11 @@ pub fn check_crate(tcx: ty::ctxt,
return last_use_map;
}
impl LiveNode: to_str::ToStr {
impl to_str::ToStr for LiveNode {
pure fn to_str(&self) -> ~str { fmt!("ln(%u)", **self) }
}
impl Variable: to_str::ToStr {
impl to_str::ToStr for Variable {
pure fn to_str(&self) -> ~str { fmt!("v(%u)", **self) }
}

2
src/librustc/middle/trans/cabi.rs
View file

@ -179,7 +179,7 @@ pub impl FnType {
enum LLVM_ABIInfo { LLVM_ABIInfo }
impl LLVM_ABIInfo: ABIInfo {
impl ABIInfo for LLVM_ABIInfo {
fn compute_info(&self,
atys: &[TypeRef],
rty: TypeRef,

4
src/librustc/middle/trans/cabi_x86_64.rs
View file

@ -32,7 +32,7 @@ enum x86_64_reg_class {
memory_class
}
impl x86_64_reg_class : cmp::Eq {
impl cmp::Eq for x86_64_reg_class {
pure fn eq(&self, other: &x86_64_reg_class) -> bool {
((*self) as uint) == ((*other) as uint)
}
@ -402,7 +402,7 @@ fn x86_64_tys(atys: &[TypeRef],
enum X86_64_ABIInfo { X86_64_ABIInfo }
impl X86_64_ABIInfo: ABIInfo {
impl ABIInfo for X86_64_ABIInfo {
fn compute_info(&self,
atys: &[TypeRef],
rty: TypeRef,

4
src/librustc/middle/trans/expr.rs
View file

@ -165,7 +165,7 @@ impl Dest {
}
}
impl Dest : cmp::Eq {
impl cmp::Eq for Dest {
pure fn eq(&self, other: &Dest) -> bool {
match ((*self), (*other)) {
(SaveIn(e0a), SaveIn(e0b)) => e0a == e0b,
@ -1516,7 +1516,7 @@ pub enum cast_kind {
cast_other,
}
impl cast_kind : cmp::Eq {
impl cmp::Eq for cast_kind {
pure fn eq(&self, other: &cast_kind) -> bool {
match ((*self), (*other)) {
(cast_pointer, cast_pointer) => true,

56
src/librustc/middle/ty.rs
View file

@ -111,7 +111,7 @@ pub struct creader_cache_key {
type creader_cache = HashMap<creader_cache_key, t>;
impl creader_cache_key : to_bytes::IterBytes {
impl to_bytes::IterBytes for creader_cache_key {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_3(&self.cnum, &self.pos, &self.len, lsb0, f);
}
@ -125,7 +125,7 @@ struct intern_key {
// NB: Do not replace this with #[deriving_eq]. The automatically-derived
// implementation will not recurse through sty and you will get stack
// exhaustion.
impl intern_key : cmp::Eq {
impl cmp::Eq for intern_key {
pure fn eq(&self, other: &intern_key) -> bool {
unsafe {
*self.sty == *other.sty && self.o_def_id == other.o_def_id
@ -136,7 +136,7 @@ impl intern_key : cmp::Eq {
}
}
impl intern_key : to_bytes::IterBytes {
impl to_bytes::IterBytes for intern_key {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
unsafe {
to_bytes::iter_bytes_2(&*self.sty, &self.o_def_id, lsb0, f);
@ -155,7 +155,7 @@ pub type opt_region_variance = Option<region_variance>;
#[auto_decode]
pub enum region_variance { rv_covariant, rv_invariant, rv_contravariant }
impl region_variance : cmp::Eq {
impl cmp::Eq for region_variance {
pure fn eq(&self, other: &region_variance) -> bool {
match ((*self), (*other)) {
(rv_covariant, rv_covariant) => true,
@ -372,13 +372,13 @@ pub struct FnSig {
output: t
}
impl BareFnTy : to_bytes::IterBytes {
impl to_bytes::IterBytes for BareFnTy {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_3(&self.purity, &self.abi, &self.sig, lsb0, f)
}
}
impl ClosureTy : to_bytes::IterBytes {
impl to_bytes::IterBytes for ClosureTy {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_5(&self.purity, &self.sigil, &self.onceness,
&self.region, &self.sig, lsb0, f)
@ -391,7 +391,7 @@ pub struct param_ty {
def_id: def_id
}
impl param_ty : to_bytes::IterBytes {
impl to_bytes::IterBytes for param_ty {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.idx, &self.def_id, lsb0, f)
}
@ -597,7 +597,7 @@ pub enum InferTy {
FloatVar(FloatVid)
}
impl InferTy : to_bytes::IterBytes {
impl to_bytes::IterBytes for InferTy {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
TyVar(ref tv) => to_bytes::iter_bytes_2(&0u8, tv, lsb0, f),
@ -614,7 +614,7 @@ pub enum InferRegion {
ReSkolemized(uint, bound_region)
}
impl InferRegion : to_bytes::IterBytes {
impl to_bytes::IterBytes for InferRegion {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
ReVar(ref rv) => to_bytes::iter_bytes_2(&0u8, rv, lsb0, f),
@ -623,7 +623,7 @@ impl InferRegion : to_bytes::IterBytes {
}
}
impl InferRegion : cmp::Eq {
impl cmp::Eq for InferRegion {
pure fn eq(&self, other: &InferRegion) -> bool {
match ((*self), *other) {
(ReVar(rva), ReVar(rvb)) => {
@ -640,7 +640,7 @@ impl InferRegion : cmp::Eq {
}
}
impl param_bound : to_bytes::IterBytes {
impl to_bytes::IterBytes for param_bound {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
bound_copy => 0u8.iter_bytes(lsb0, f),
@ -1817,19 +1817,19 @@ pub impl TypeContents {
}
}
impl TypeContents : ops::Add<TypeContents,TypeContents> {
impl ops::Add<TypeContents,TypeContents> for TypeContents {
pure fn add(&self, other: &TypeContents) -> TypeContents {
TypeContents {bits: self.bits | other.bits}
}
}
impl TypeContents : ops::Sub<TypeContents,TypeContents> {
impl ops::Sub<TypeContents,TypeContents> for TypeContents {
pure fn sub(&self, other: &TypeContents) -> TypeContents {
TypeContents {bits: self.bits & !other.bits}
}
}
impl TypeContents : ToStr {
impl ToStr for TypeContents {
pure fn to_str(&self) -> ~str {
fmt!("TypeContents(%s)", u32::to_str_radix(self.bits, 2))
}
@ -2586,7 +2586,7 @@ pub fn index_sty(cx: ctxt, sty: &sty) -> Option<mt> {
}
}
impl bound_region : to_bytes::IterBytes {
impl to_bytes::IterBytes for bound_region {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
ty::br_self => 0u8.iter_bytes(lsb0, f),
@ -2606,7 +2606,7 @@ impl bound_region : to_bytes::IterBytes {
}
}
impl Region : to_bytes::IterBytes {
impl to_bytes::IterBytes for Region {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
re_bound(ref br) =>
@ -2626,7 +2626,7 @@ impl Region : to_bytes::IterBytes {
}
}
impl vstore : to_bytes::IterBytes {
impl to_bytes::IterBytes for vstore {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
vstore_fixed(ref u) =>
@ -2641,7 +2641,7 @@ impl vstore : to_bytes::IterBytes {
}
}
impl substs : to_bytes::IterBytes {
impl to_bytes::IterBytes for substs {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_3(&self.self_r,
&self.self_ty,
@ -2649,28 +2649,28 @@ impl substs : to_bytes::IterBytes {
}
}
impl mt : to_bytes::IterBytes {
impl to_bytes::IterBytes for mt {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.ty,
&self.mutbl, lsb0, f)
}
}
impl field : to_bytes::IterBytes {
impl to_bytes::IterBytes for field {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.ident,
&self.mt, lsb0, f)
}
}
impl arg : to_bytes::IterBytes {
impl to_bytes::IterBytes for arg {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.mode,
&self.ty, lsb0, f)
}
}
impl FnSig : to_bytes::IterBytes {
impl to_bytes::IterBytes for FnSig {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.inputs,
&self.output,
@ -2678,7 +2678,7 @@ impl FnSig : to_bytes::IterBytes {
}
}
impl sty : to_bytes::IterBytes {
impl to_bytes::IterBytes for sty {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
ty_nil => 0u8.iter_bytes(lsb0, f),
@ -4383,14 +4383,14 @@ pub fn get_impl_id(tcx: ctxt, trait_id: def_id, self_ty: t) -> def_id {
}
}
impl mt : cmp::Eq {
impl cmp::Eq for mt {
pure fn eq(&self, other: &mt) -> bool {
(*self).ty == (*other).ty && (*self).mutbl == (*other).mutbl
}
pure fn ne(&self, other: &mt) -> bool { !(*self).eq(other) }
}
impl vstore : cmp::Eq {
impl cmp::Eq for vstore {
pure fn eq(&self, other: &vstore) -> bool {
match (*self) {
vstore_fixed(e0a) => {
@ -4422,7 +4422,7 @@ impl vstore : cmp::Eq {
pure fn ne(&self, other: &vstore) -> bool { !(*self).eq(other) }
}
impl Region : cmp::Eq {
impl cmp::Eq for Region {
pure fn eq(&self, other: &Region) -> bool {
match (*self) {
re_bound(e0a) => {
@ -4460,7 +4460,7 @@ impl Region : cmp::Eq {
pure fn ne(&self, other: &Region) -> bool { !(*self).eq(other) }
}
impl bound_region : cmp::Eq {
impl cmp::Eq for bound_region {
pure fn eq(&self, other: &bound_region) -> bool {
match (*self) {
br_self => {
@ -4498,7 +4498,7 @@ impl bound_region : cmp::Eq {
pure fn ne(&self, other: &bound_region) -> bool { !(*self).eq(other) }
}
impl param_bound : cmp::Eq {
impl cmp::Eq for param_bound {
pure fn eq(&self, other: &param_bound) -> bool {
match (*self) {
bound_copy => {

6
src/librustc/middle/typeck/infer/mod.rs
View file

@ -490,7 +490,7 @@ trait then {
-> Result<T,ty::type_err>;
}
impl ures: then {
impl then for ures {
fn then<T:Copy>(f: fn() -> Result<T,ty::type_err>)
-> Result<T,ty::type_err> {
self.chain(|_i| f())
@ -501,7 +501,7 @@ trait ToUres {
fn to_ures() -> ures;
}
impl<T> cres<T>: ToUres {
impl<T> ToUres for cres<T> {
fn to_ures() -> ures {
match self {
Ok(ref _v) => Ok(()),
@ -514,7 +514,7 @@ trait CresCompare<T> {
fn compare(t: T, f: fn() -> ty::type_err) -> cres<T>;
}
impl<T:Copy Eq> cres<T>: CresCompare<T> {
impl<T:Copy Eq> CresCompare<T> for cres<T> {
fn compare(t: T, f: fn() -> ty::type_err) -> cres<T> {
do self.chain |s| {
if s == t {

8
src/librustc/middle/typeck/infer/region_inference.rs
View file

@ -568,7 +568,7 @@ enum Constraint {
ConstrainVarSubReg(RegionVid, Region)
}
impl Constraint : cmp::Eq {
impl cmp::Eq for Constraint {
pure fn eq(&self, other: &Constraint) -> bool {
match ((*self), (*other)) {
(ConstrainVarSubVar(v0a, v1a), ConstrainVarSubVar(v0b, v1b)) => {
@ -588,7 +588,7 @@ impl Constraint : cmp::Eq {
pure fn ne(&self, other: &Constraint) -> bool { !(*self).eq(other) }
}
impl Constraint : to_bytes::IterBytes {
impl to_bytes::IterBytes for Constraint {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
match *self {
ConstrainVarSubVar(ref v0, ref v1) =>
@ -608,14 +608,14 @@ struct TwoRegions {
b: Region,
}
impl TwoRegions : cmp::Eq {
impl cmp::Eq for TwoRegions {
pure fn eq(&self, other: &TwoRegions) -> bool {
(*self).a == (*other).a && (*self).b == (*other).b
}
pure fn ne(&self, other: &TwoRegions) -> bool { !(*self).eq(other) }
}
impl TwoRegions : to_bytes::IterBytes {
impl to_bytes::IterBytes for TwoRegions {
pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
to_bytes::iter_bytes_2(&self.a, &self.b, lsb0, f)
}

2
src/librustc/middle/typeck/mod.rs
View file

@ -279,7 +279,7 @@ trait get_and_find_region {
fn find(br: ty::bound_region) -> Option<ty::Region>;
}
impl isr_alist: get_and_find_region {
impl get_and_find_region for isr_alist {
fn get(br: ty::bound_region) -> ty::Region {
self.find(br).get()
}

2
src/librustdoc/astsrv.rs
View file

@ -59,7 +59,7 @@ pub struct Srv {
ch: SharedChan<Msg>
}
impl Srv: Clone {
impl Clone for Srv {
fn clone(&self) -> Srv {
Srv {
ch: self.ch.clone()

4
src/librustdoc/config.rs
View file

@ -28,7 +28,7 @@ pub enum OutputFormat {
pub PandocHtml
}
impl OutputFormat : cmp::Eq {
impl cmp::Eq for OutputFormat {
pure fn eq(&self, other: &OutputFormat) -> bool {
((*self) as uint) == ((*other) as uint)
}
@ -43,7 +43,7 @@ pub enum OutputStyle {
pub DocPerMod
}
impl OutputStyle : cmp::Eq {
impl cmp::Eq for OutputStyle {
pure fn eq(&self, other: &OutputStyle) -> bool {
((*self) as uint) == ((*other) as uint)
}

2
src/librustdoc/demo.rs
View file

@ -187,7 +187,7 @@ trait TheShunnedHouse {
}
/// Whatever
impl OmNomNomy: TheShunnedHouse {
impl TheShunnedHouse for OmNomNomy {
fn dingy_house(&self, _unkempt_yard: int) {
}

20
src/librustdoc/doc.rs
View file

@ -284,7 +284,7 @@ pub trait PageUtils {
fn types(&self) -> ~[TyDoc];
}
impl ~[Page]: PageUtils {
impl PageUtils for ~[Page] {
fn mods(&self) -> ~[ModDoc] {
do vec::filter_mapped(*self) |page| {
@ -363,7 +363,7 @@ pub trait Item {
pure fn item(&self) -> ItemDoc;
}
impl ItemTag: Item {
impl Item for ItemTag {
pure fn item(&self) -> ItemDoc {
match self {
&doc::ModTag(ref doc) => copy doc.item,
@ -379,31 +379,31 @@ impl ItemTag: Item {
}
}
impl SimpleItemDoc: Item {
impl Item for SimpleItemDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
impl ModDoc: Item {
impl Item for ModDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
impl NmodDoc: Item {
impl Item for NmodDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
impl EnumDoc: Item {
impl Item for EnumDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
impl TraitDoc: Item {
impl Item for TraitDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
impl ImplDoc: Item {
impl Item for ImplDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
impl StructDoc: Item {
impl Item for StructDoc {
pure fn item(&self) -> ItemDoc { copy self.item }
}
@ -416,7 +416,7 @@ pub trait ItemUtils {
pure fn sections(&self) -> ~[Section];
}
impl<A:Item> A: ItemUtils {
impl<A:Item> ItemUtils for A {
pure fn id(&self) -> AstId {
self.item().id
}

2
src/librustdoc/fold.rs
View file

@ -35,7 +35,7 @@ pub struct Fold<T> {
fold_struct: FoldStruct<T>
}
impl<T: Clone> Fold<T>: Clone {
impl<T: Clone> Clone for Fold<T> {
fn clone(&self) -> Fold<T> {
Fold {
ctxt: self.ctxt.clone(),

2
src/librustdoc/markdown_writer.rs
View file

@ -43,7 +43,7 @@ pub trait WriterUtils {
fn write_done(&self);
}
impl Writer: WriterUtils {
impl WriterUtils for Writer {
fn write_str(&self, str: ~str) {
(*self)(Write(str));
}

2
src/librustdoc/path_pass.rs
View file

@ -34,7 +34,7 @@ struct Ctxt {
mut path: ~[~str]
}
impl Ctxt: Clone {
impl Clone for Ctxt {
fn clone(&self) -> Ctxt {
Ctxt {
srv: self.srv.clone(),

2
src/librustdoc/util.rs
View file

@ -17,6 +17,6 @@ pub struct NominalOp<T> {
op: T
}
impl<T: Copy> NominalOp<T>: Clone {
impl<T: Copy> Clone for NominalOp<T> {
fn clone(&self) -> NominalOp<T> { copy *self }
}

6
src/libstd/arc.rs
View file

@ -117,7 +117,7 @@ pub fn unwrap<T: Const Owned>(rc: ARC<T>) -> T {
unsafe { unwrap_shared_mutable_state(move x) }
}
impl<T: Const Owned> ARC<T>: Clone {
impl<T: Const Owned> Clone for ARC<T> {
fn clone(&self) -> ARC<T> {
clone(self)
}
@ -148,7 +148,7 @@ pub fn mutex_arc_with_condvars<T: Owned>(user_data: T,
MutexARC { x: unsafe { shared_mutable_state(move data) } }
}
impl<T: Owned> MutexARC<T>: Clone {
impl<T: Owned> Clone for MutexARC<T> {
/// Duplicate a mutex-protected ARC, as arc::clone.
fn clone(&self) -> MutexARC<T> {
// NB: Cloning the underlying mutex is not necessary. Its reference
@ -247,7 +247,7 @@ struct PoisonOnFail {
failed: *mut bool,
}
impl PoisonOnFail : Drop {
impl Drop for PoisonOnFail {
fn finalize(&self) {
unsafe {
/* assert !*self.failed;

2
src/libstd/arena.rs
View file

@ -81,7 +81,7 @@ pub struct Arena {
priv mut chunks: @List<Chunk>,
}
impl Arena : Drop {
impl Drop for Arena {
fn finalize(&self) {
unsafe {
destroy_chunk(&self.head);

8
src/libstd/base64.rs
View file

@ -17,7 +17,7 @@ pub trait ToBase64 {
pure fn to_base64() -> ~str;
}
impl &[u8]: ToBase64 {
impl ToBase64 for &[u8] {
pure fn to_base64() -> ~str {
let chars = str::chars(
~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
@ -70,7 +70,7 @@ impl &[u8]: ToBase64 {
}
}
impl &str: ToBase64 {
impl ToBase64 for &str {
pure fn to_base64() -> ~str {
str::to_bytes(self).to_base64()
}
@ -80,7 +80,7 @@ pub trait FromBase64 {
pure fn from_base64() -> ~[u8];
}
impl ~[u8]: FromBase64 {
impl FromBase64 for ~[u8] {
pure fn from_base64() -> ~[u8] {
if self.len() % 4u != 0u { fail!(~"invalid base64 length"); }
@ -142,7 +142,7 @@ impl ~[u8]: FromBase64 {
}
}
impl ~str: FromBase64 {
impl FromBase64 for ~str {
pure fn from_base64() -> ~[u8] {
str::to_bytes(self).from_base64()
}

64
src/libstd/bigint.rs
View file

@ -75,29 +75,29 @@ pub struct BigUint {
priv data: ~[BigDigit]
}
impl BigUint : Eq {
impl Eq for BigUint {
pure fn eq(&self, other: &BigUint) -> bool { self.cmp(other) == 0 }
pure fn ne(&self, other: &BigUint) -> bool { self.cmp(other) != 0 }
}
impl BigUint : Ord {
impl Ord for BigUint {
pure fn lt(&self, other: &BigUint) -> bool { self.cmp(other) < 0 }
pure fn le(&self, other: &BigUint) -> bool { self.cmp(other) <= 0 }
pure fn ge(&self, other: &BigUint) -> bool { self.cmp(other) >= 0 }
pure fn gt(&self, other: &BigUint) -> bool { self.cmp(other) > 0 }
}
impl BigUint : ToStr {
impl ToStr for BigUint {
pure fn to_str(&self) -> ~str { self.to_str_radix(10) }
}
impl BigUint : from_str::FromStr {
impl from_str::FromStr for BigUint {
static pure fn from_str(s: &str) -> Option<BigUint> {
BigUint::from_str_radix(s, 10)
}
}
impl BigUint : Shl<uint, BigUint> {
impl Shl<uint, BigUint> for BigUint {
pure fn shl(&self, rhs: &uint) -> BigUint {
let n_unit = *rhs / BigDigit::bits;
let n_bits = *rhs % BigDigit::bits;
@ -105,7 +105,7 @@ impl BigUint : Shl<uint, BigUint> {
}
}
impl BigUint : Shr<uint, BigUint> {
impl Shr<uint, BigUint> for BigUint {
pure fn shr(&self, rhs: &uint) -> BigUint {
let n_unit = *rhs / BigDigit::bits;
let n_bits = *rhs % BigDigit::bits;
@ -113,15 +113,15 @@ impl BigUint : Shr<uint, BigUint> {
}
}
impl BigUint : Zero {
impl Zero for BigUint {
static pure fn zero() -> BigUint { BigUint::new(~[]) }
}
impl BigUint : One {
impl One for BigUint {
static pub pure fn one() -> BigUint { BigUint::new(~[1]) }
}
impl BigUint : Add<BigUint, BigUint> {
impl Add<BigUint, BigUint> for BigUint {
pure fn add(&self, other: &BigUint) -> BigUint {
let new_len = uint::max(self.data.len(), other.data.len());
@ -140,7 +140,7 @@ impl BigUint : Add<BigUint, BigUint> {
}
}
impl BigUint : Sub<BigUint, BigUint> {
impl Sub<BigUint, BigUint> for BigUint {
pure fn sub(&self, other: &BigUint) -> BigUint {
let new_len = uint::max(self.data.len(), other.data.len());
@ -165,7 +165,7 @@ impl BigUint : Sub<BigUint, BigUint> {
}
}
impl BigUint : Mul<BigUint, BigUint> {
impl Mul<BigUint, BigUint> for BigUint {
pure fn mul(&self, other: &BigUint) -> BigUint {
if self.is_zero() || other.is_zero() { return Zero::zero(); }
@ -230,25 +230,25 @@ impl BigUint : Mul<BigUint, BigUint> {
}
}
impl BigUint : Div<BigUint, BigUint> {
impl Div<BigUint, BigUint> for BigUint {
pure fn div(&self, other: &BigUint) -> BigUint {
let (d, _) = self.divmod(other);
return d;
}
}
impl BigUint : Modulo<BigUint, BigUint> {
impl Modulo<BigUint, BigUint> for BigUint {
pure fn modulo(&self, other: &BigUint) -> BigUint {
let (_, m) = self.divmod(other);
return m;
}
}
impl BigUint : Neg<BigUint> {
impl Neg<BigUint> for BigUint {
pure fn neg(&self) -> BigUint { fail!() }
}
impl BigUint : IntConvertible {
impl IntConvertible for BigUint {
pure fn to_int(&self) -> int {
uint::min(self.to_uint(), int::max_value as uint) as int
}
@ -554,12 +554,12 @@ priv pure fn get_radix_base(radix: uint) -> (uint, uint) {
/// A Sign is a BigInt's composing element.
pub enum Sign { Minus, Zero, Plus }
impl Sign : Eq {
impl Eq for Sign {
pure fn eq(&self, other: &Sign) -> bool { self.cmp(other) == 0 }
pure fn ne(&self, other: &Sign) -> bool { self.cmp(other) != 0 }
}
impl Sign : Ord {
impl Ord for Sign {
pure fn lt(&self, other: &Sign) -> bool { self.cmp(other) < 0 }
pure fn le(&self, other: &Sign) -> bool { self.cmp(other) <= 0 }
pure fn ge(&self, other: &Sign) -> bool { self.cmp(other) >= 0 }
@ -592,53 +592,53 @@ pub struct BigInt {
priv data: BigUint
}
impl BigInt : Eq {
impl Eq for BigInt {
pure fn eq(&self, other: &BigInt) -> bool { self.cmp(other) == 0 }
pure fn ne(&self, other: &BigInt) -> bool { self.cmp(other) != 0 }
}
impl BigInt : Ord {
impl Ord for BigInt {
pure fn lt(&self, other: &BigInt) -> bool { self.cmp(other) < 0 }
pure fn le(&self, other: &BigInt) -> bool { self.cmp(other) <= 0 }
pure fn ge(&self, other: &BigInt) -> bool { self.cmp(other) >= 0 }
pure fn gt(&self, other: &BigInt) -> bool { self.cmp(other) > 0 }
}
impl BigInt : ToStr {
impl ToStr for BigInt {
pure fn to_str(&self) -> ~str { self.to_str_radix(10) }
}
impl BigInt : from_str::FromStr {
impl from_str::FromStr for BigInt {
static pure fn from_str(s: &str) -> Option<BigInt> {
BigInt::from_str_radix(s, 10)
}
}
impl BigInt : Shl<uint, BigInt> {
impl Shl<uint, BigInt> for BigInt {
pure fn shl(&self, rhs: &uint) -> BigInt {
BigInt::from_biguint(self.sign, self.data << *rhs)
}
}
impl BigInt : Shr<uint, BigInt> {
impl Shr<uint, BigInt> for BigInt {
pure fn shr(&self, rhs: &uint) -> BigInt {
BigInt::from_biguint(self.sign, self.data >> *rhs)
}
}
impl BigInt : Zero {
impl Zero for BigInt {
static pub pure fn zero() -> BigInt {
BigInt::from_biguint(Zero, Zero::zero())
}
}
impl BigInt : One {
impl One for BigInt {
static pub pure fn one() -> BigInt {
BigInt::from_biguint(Plus, One::one())
}
}
impl BigInt : Add<BigInt, BigInt> {
impl Add<BigInt, BigInt> for BigInt {
pure fn add(&self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) {
(Zero, _) => copy *other,
@ -652,7 +652,7 @@ impl BigInt : Add<BigInt, BigInt> {
}
}
impl BigInt : Sub<BigInt, BigInt> {
impl Sub<BigInt, BigInt> for BigInt {
pure fn sub(&self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) {
(Zero, _) => -other,
@ -672,7 +672,7 @@ impl BigInt : Sub<BigInt, BigInt> {
}
}
impl BigInt : Mul<BigInt, BigInt> {
impl Mul<BigInt, BigInt> for BigInt {
pure fn mul(&self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) {
(Zero, _) | (_, Zero) => Zero::zero(),
@ -686,27 +686,27 @@ impl BigInt : Mul<BigInt, BigInt> {
}
}
impl BigInt : Div<BigInt, BigInt> {
impl Div<BigInt, BigInt> for BigInt {
pure fn div(&self, other: &BigInt) -> BigInt {
let (d, _) = self.divmod(other);
return d;
}
}
impl BigInt : Modulo<BigInt, BigInt> {
impl Modulo<BigInt, BigInt> for BigInt {
pure fn modulo(&self, other: &BigInt) -> BigInt {
let (_, m) = self.divmod(other);
return m;
}
}
impl BigInt : Neg<BigInt> {
impl Neg<BigInt> for BigInt {
pure fn neg(&self) -> BigInt {
BigInt::from_biguint(self.sign.neg(), copy self.data)
}
}
impl BigInt : IntConvertible {
impl IntConvertible for BigInt {
pure fn to_int(&self) -> int {
match self.sign {
Plus => uint::min(self.to_uint(), int::max_value as uint) as int,

4
src/libstd/bitv.rs
View file

@ -507,7 +507,7 @@ impl Bitv {
}
impl Bitv: Clone {
impl Clone for Bitv {
/// Makes a copy of a bitvector
#[inline(always)]
fn clone(&self) -> Bitv {
@ -568,7 +568,7 @@ pure fn difference(w0: uint, w1: uint) -> uint { return w0 & !w1; }
pure fn right(_w0: uint, w1: uint) -> uint { return w1; }
impl Bitv: ops::Index<uint,bool> {
impl ops::Index<uint,bool> for Bitv {
pure fn index(&self, i: uint) -> bool {
self.get(i)
}

2
src/libstd/c_vec.rs
View file

@ -56,7 +56,7 @@ struct DtorRes {
dtor: Option<fn@()>,
}
impl DtorRes : Drop {
impl Drop for DtorRes {
fn finalize(&self) {
match self.dtor {
option::None => (),

8
src/libstd/cmp.rs
View file

@ -21,7 +21,7 @@ pub trait FuzzyEq<Eps> {
pure fn fuzzy_eq_eps(&self, other: &Self, epsilon: &Eps) -> bool;
}
impl float: FuzzyEq<float> {
impl FuzzyEq<float> for float {
pure fn fuzzy_eq(&self, other: &float) -> bool {
self.fuzzy_eq_eps(other, &FUZZY_EPSILON)
}
@ -31,7 +31,7 @@ impl float: FuzzyEq<float> {
}
}
impl f32: FuzzyEq<f32> {
impl FuzzyEq<f32> for f32 {
pure fn fuzzy_eq(&self, other: &f32) -> bool {
self.fuzzy_eq_eps(other, &(FUZZY_EPSILON as f32))
}
@ -41,7 +41,7 @@ impl f32: FuzzyEq<f32> {
}
}
impl f64: FuzzyEq<f64> {
impl FuzzyEq<f64> for f64 {
pure fn fuzzy_eq(&self, other: &f64) -> bool {
self.fuzzy_eq_eps(other, &(FUZZY_EPSILON as f64))
}
@ -70,7 +70,7 @@ mod test_complex{
struct Complex { r: float, i: float }
impl Complex: FuzzyEq<float> {
impl FuzzyEq<float> for Complex {
pure fn fuzzy_eq(&self, other: &Complex) -> bool {
self.fuzzy_eq_eps(other, &FUZZY_EPSILON)
}

10
src/libstd/comm.rs
View file

@ -25,19 +25,19 @@ pub struct DuplexStream<T, U> {
priv port: Port<U>,
}
impl<T: Owned, U: Owned> DuplexStream<T, U> : GenericChan<T> {
impl<T: Owned, U: Owned> GenericChan<T> for DuplexStream<T, U> {
fn send(x: T) {
self.chan.send(move x)
}
}
impl<T: Owned, U: Owned> DuplexStream<T, U> : GenericSmartChan<T> {
impl<T: Owned, U: Owned> GenericSmartChan<T> for DuplexStream<T, U> {
fn try_send(x: T) -> bool {
self.chan.try_send(move x)
}
}
impl<T: Owned, U: Owned> DuplexStream<T, U> : GenericPort<U> {
impl<T: Owned, U: Owned> GenericPort<U> for DuplexStream<T, U> {
fn recv() -> U {
self.port.recv()
}
@ -47,13 +47,13 @@ impl<T: Owned, U: Owned> DuplexStream<T, U> : GenericPort<U> {
}
}
impl<T: Owned, U: Owned> DuplexStream<T, U> : Peekable<U> {
impl<T: Owned, U: Owned> Peekable<U> for DuplexStream<T, U> {
pure fn peek() -> bool {
self.port.peek()
}
}
impl<T: Owned, U: Owned> DuplexStream<T, U> : Selectable {
impl<T: Owned, U: Owned> Selectable for DuplexStream<T, U> {
pure fn header() -> *pipes::PacketHeader {
self.port.header()
}

2
src/libstd/deque.rs
View file

@ -67,7 +67,7 @@ pub fn create<T: Copy>() -> Deque<T> {
elts: DVec<Cell<T>>,
}
impl <T: Copy> Repr<T>: Deque<T> {
impl<T: Copy> Deque<T> for Repr<T> {
fn size() -> uint { return self.nelts; }
fn add_front(t: T) {
let oldlo: uint = self.lo;

6
src/libstd/ebml.rs
View file

@ -74,7 +74,7 @@ pub mod reader {
// ebml reading
impl Doc: ops::Index<uint,Doc> {
impl ops::Index<uint,Doc> for Doc {
pure fn index(&self, tag: uint) -> Doc {
unsafe {
get_doc(*self, tag)
@ -285,7 +285,7 @@ pub mod reader {
}
}
impl Decoder: serialize::Decoder {
impl serialize::Decoder for Decoder {
fn read_nil(&self) -> () { () }
fn read_u64(&self) -> u64 { doc_as_u64(self.next_doc(EsU64)) }
@ -577,7 +577,7 @@ pub mod writer {
}
}
impl Encoder: ::serialize::Encoder {
impl ::serialize::Encoder for Encoder {
fn emit_nil(&self) {}
fn emit_uint(&self, v: uint) {

10
src/libstd/flatpipes.rs
View file

@ -303,7 +303,7 @@ pub impl<T,U:Unflattener<T>,P:BytePort> FlatPort<T, U, P>: GenericPort<T> {
}
}
impl<T,F:Flattener<T>,C:ByteChan> FlatChan<T, F, C>: GenericChan<T> {
impl<T,F:Flattener<T>,C:ByteChan> GenericChan<T> for FlatChan<T, F, C> {
fn send(val: T) {
self.byte_chan.send(CONTINUE.to_vec());
let bytes = self.flattener.flatten(move val);
@ -474,7 +474,7 @@ pub mod flatteners {
static fn from_writer(w: Writer) -> Self;
}
impl json::Decoder: FromReader {
impl FromReader for json::Decoder {
static fn from_reader(r: Reader) -> json::Decoder {
match json::from_reader(r) {
Ok(move json) => {
@ -485,13 +485,13 @@ pub mod flatteners {
}
}
impl json::Encoder: FromWriter {
impl FromWriter for json::Encoder {
static fn from_writer(w: Writer) -> json::Encoder {
json::Encoder(move w)
}
}
impl ebml::reader::Decoder: FromReader {
impl FromReader for ebml::reader::Decoder {
static fn from_reader(r: Reader) -> ebml::reader::Decoder {
let buf = @r.read_whole_stream();
let doc = ebml::reader::Doc(buf);
@ -499,7 +499,7 @@ pub mod flatteners {
}
}
impl ebml::writer::Encoder: FromWriter {
impl FromWriter for ebml::writer::Encoder {
static fn from_writer(w: Writer) -> ebml::writer::Encoder {
ebml::writer::Encoder(move w)
}

2
src/libstd/future.rs
View file

@ -36,7 +36,7 @@ pub struct Future<A> {
// FIXME(#2829) -- futures should not be copyable, because they close
// over fn~'s that have pipes and so forth within!
impl<A> Future<A> : Drop {
impl<A> Drop for Future<A> {
fn finalize(&self) {}
}

2
src/libstd/io_util.rs
View file

@ -42,7 +42,7 @@ pub impl BufReader {
}
}
impl BufReader: Reader {
impl Reader for BufReader {
fn read(&self, bytes: &mut [u8], len: uint) -> uint {
self.as_bytes_reader(|r| r.read(bytes, len) )
}

58
src/libstd/json.rs
View file

@ -949,7 +949,7 @@ pub impl Decoder: serialize::Decoder {
}
}
impl Json : Eq {
impl Eq for Json {
pure fn eq(&self, other: &Json) -> bool {
match (self) {
&Number(f0) =>
@ -987,7 +987,7 @@ impl Json : Eq {
}
/// Test if two json values are less than one another
impl Json : Ord {
impl Ord for Json {
pure fn lt(&self, other: &Json) -> bool {
match (*self) {
Number(f0) => {
@ -1063,7 +1063,7 @@ impl Json : Ord {
pure fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self)) }
}
impl Error : Eq {
impl Eq for Error {
pure fn eq(&self, other: &Error) -> bool {
(*self).line == other.line &&
(*self).col == other.col &&
@ -1074,83 +1074,83 @@ impl Error : Eq {
trait ToJson { fn to_json() -> Json; }
impl Json: ToJson {
impl ToJson for Json {
fn to_json() -> Json { copy self }
}
impl @Json: ToJson {
impl ToJson for @Json {
fn to_json() -> Json { (*self).to_json() }
}
impl int: ToJson {
impl ToJson for int {
fn to_json() -> Json { Number(self as float) }
}
impl i8: ToJson {
impl ToJson for i8 {
fn to_json() -> Json { Number(self as float) }
}
impl i16: ToJson {
impl ToJson for i16 {
fn to_json() -> Json { Number(self as float) }
}
impl i32: ToJson {
impl ToJson for i32 {
fn to_json() -> Json { Number(self as float) }
}
impl i64: ToJson {
impl ToJson for i64 {
fn to_json() -> Json { Number(self as float) }
}
impl uint: ToJson {
impl ToJson for uint {
fn to_json() -> Json { Number(self as float) }
}
impl u8: ToJson {
impl ToJson for u8 {
fn to_json() -> Json { Number(self as float) }
}
impl u16: ToJson {
impl ToJson for u16 {
fn to_json() -> Json { Number(self as float) }
}
impl u32: ToJson {
impl ToJson for u32 {
fn to_json() -> Json { Number(self as float) }
}
impl u64: ToJson {
impl ToJson for u64 {
fn to_json() -> Json { Number(self as float) }
}
impl float: ToJson {
impl ToJson for float {
fn to_json() -> Json { Number(self) }
}
impl f32: ToJson {
impl ToJson for f32 {
fn to_json() -> Json { Number(self as float) }
}
impl f64: ToJson {
impl ToJson for f64 {
fn to_json() -> Json { Number(self as float) }
}
impl (): ToJson {
impl ToJson for () {
fn to_json() -> Json { Null }
}
impl bool: ToJson {
impl ToJson for bool {
fn to_json() -> Json { Boolean(self) }
}
impl ~str: ToJson {
impl ToJson for ~str {
fn to_json() -> Json { String(copy self) }
}
impl @~str: ToJson {
impl ToJson for @~str {
fn to_json() -> Json { String(copy *self) }
}
impl <A: ToJson, B: ToJson> (A, B): ToJson {
impl<A: ToJson, B: ToJson> ToJson for (A, B) {
fn to_json() -> Json {
match self {
(ref a, ref b) => {
@ -1160,7 +1160,7 @@ impl <A: ToJson, B: ToJson> (A, B): ToJson {
}
}
impl <A: ToJson, B: ToJson, C: ToJson> (A, B, C): ToJson {
impl<A: ToJson, B: ToJson, C: ToJson> ToJson for (A, B, C) {
fn to_json() -> Json {
match self {
(ref a, ref b, ref c) => {
@ -1170,11 +1170,11 @@ impl <A: ToJson, B: ToJson, C: ToJson> (A, B, C): ToJson {
}
}
impl <A: ToJson> ~[A]: ToJson {
impl<A: ToJson> ToJson for ~[A] {
fn to_json() -> Json { List(self.map(|elt| elt.to_json())) }
}
impl <A: ToJson Copy> LinearMap<~str, A>: ToJson {
impl<A: ToJson Copy> ToJson for LinearMap<~str, A> {
fn to_json() -> Json {
let mut d = LinearMap::new();
for self.each |&(key, value)| {
@ -1184,7 +1184,7 @@ impl <A: ToJson Copy> LinearMap<~str, A>: ToJson {
}
}
impl <A: ToJson> Option<A>: ToJson {
impl<A: ToJson> ToJson for Option<A> {
fn to_json() -> Json {
match self {
None => Null,
@ -1193,11 +1193,11 @@ impl <A: ToJson> Option<A>: ToJson {
}
}
impl Json: to_str::ToStr {
impl to_str::ToStr for Json {
pure fn to_str(&self) -> ~str { to_str(self) }
}
impl Error: to_str::ToStr {
impl to_str::ToStr for Error {
pure fn to_str(&self) -> ~str {
fmt!("%u:%u: %s", self.line, self.col, *self.msg)
}

2
src/libstd/net_ip.rs
View file

@ -193,7 +193,7 @@ pub mod v4 {
unsafe fn as_u32() -> u32;
}
impl Ipv4Rep: AsUnsafeU32 {
impl AsUnsafeU32 for Ipv4Rep {
// this is pretty dastardly, i know
unsafe fn as_u32() -> u32 {
*((ptr::addr_of(&self)) as *u32)

8
src/libstd/net_tcp.rs
View file

@ -51,7 +51,7 @@ pub struct TcpSocket {
socket_data: @TcpSocketData,
}
impl TcpSocket : Drop {
impl Drop for TcpSocket {
fn finalize(&self) {
unsafe {
tear_down_socket_data(self.socket_data)
@ -863,7 +863,7 @@ impl TcpSocket {
}
/// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
impl TcpSocketBuf: io::Reader {
impl io::Reader for TcpSocketBuf {
fn read(&self, buf: &mut [u8], len: uint) -> uint {
if len == 0 { return 0 }
let mut count: uint = 0;
@ -963,7 +963,7 @@ impl TcpSocketBuf: io::Reader {
}
/// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
impl TcpSocketBuf: io::Writer {
impl io::Writer for TcpSocketBuf {
pub fn write(&self, data: &[const u8]) {
unsafe {
let socket_data_ptr =
@ -1264,7 +1264,7 @@ trait ToTcpErr {
fn to_tcp_err() -> TcpErrData;
}
impl uv::ll::uv_err_data: ToTcpErr {
impl ToTcpErr for uv::ll::uv_err_data {
fn to_tcp_err() -> TcpErrData {
TcpErrData { err_name: self.err_name, err_msg: self.err_msg }
}

6
src/libstd/net_url.rs
View file

@ -668,7 +668,7 @@ pub pure fn from_str(rawurl: &str) -> Result<Url, ~str> {
Ok(Url::new(scheme, userinfo, host, port, path, query, fragment))
}
impl Url: FromStr {
impl FromStr for Url {
static pure fn from_str(s: &str) -> Option<Url> {
match from_str(s) {
Ok(move url) => Some(url),
@ -718,13 +718,13 @@ pub pure fn to_str(url: &Url) -> ~str {
fmt!("%s:%s%s%s%s", url.scheme, authority, url.path, query, fragment)
}
impl Url: to_str::ToStr {
impl to_str::ToStr for Url {
pub pure fn to_str(&self) -> ~str {
to_str(self)
}
}
impl Url: to_bytes::IterBytes {
impl to_bytes::IterBytes for Url {
pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {
self.to_str().iter_bytes(lsb0, f)
}

8
src/libstd/oldmap.rs
View file

@ -156,12 +156,12 @@ pub mod chained {
}
}
impl<K: Eq IterBytes Hash, V> T<K, V>: Container {
impl<K: Eq IterBytes Hash, V> Container for T<K, V> {
pure fn len(&self) -> uint { self.count }
pure fn is_empty(&self) -> bool { self.count == 0 }
}
impl<K: Eq IterBytes Hash, V> T<K, V>: Mutable {
impl<K: Eq IterBytes Hash, V> Mutable for T<K, V> {
fn clear(&mut self) {
self.count = 0u;
self.chains = chains(initial_capacity);
@ -347,7 +347,7 @@ pub mod chained {
}
}
impl<K:Eq IterBytes Hash Copy ToStr, V: ToStr Copy> T<K, V>: ToStr {
impl<K:Eq IterBytes Hash Copy ToStr, V: ToStr Copy> ToStr for T<K, V> {
pure fn to_str(&self) -> ~str {
unsafe {
// Meh -- this should be safe
@ -356,7 +356,7 @@ pub mod chained {
}
}
impl<K:Eq IterBytes Hash Copy, V: Copy> T<K, V>: ops::Index<K, V> {
impl<K:Eq IterBytes Hash Copy, V: Copy> ops::Index<K, V> for T<K, V> {
pure fn index(&self, k: K) -> V {
self.get(&k)
}

6
src/libstd/oldsmallintmap.rs
View file

@ -78,7 +78,7 @@ pub pure fn contains_key<T: Copy>(self: SmallIntMap<T>, key: uint) -> bool {
return !find(self, key).is_none();
}
impl<V> SmallIntMap<V>: Container {
impl<V> Container for SmallIntMap<V> {
/// Return the number of elements in the map
pure fn len(&self) -> uint {
let mut sz = 0u;
@ -95,7 +95,7 @@ impl<V> SmallIntMap<V>: Container {
pure fn is_empty(&self) -> bool { self.len() == 0 }
}
impl<V> SmallIntMap<V>: Mutable {
impl<V> Mutable for SmallIntMap<V> {
fn clear(&mut self) { self.v.set(~[]) }
}
@ -162,7 +162,7 @@ impl<V: Copy> SmallIntMap<V> {
}
}
impl<V: Copy> SmallIntMap<V>: ops::Index<uint, V> {
impl<V: Copy> ops::Index<uint, V> for SmallIntMap<V> {
pure fn index(&self, key: uint) -> V {
unsafe {
get(*self, key)

6
src/libstd/priority_queue.rs
View file

@ -27,7 +27,7 @@ pub struct PriorityQueue<T> {
priv data: ~[T],
}
impl <T: Ord> PriorityQueue<T>: BaseIter<T> {
impl<T: Ord> BaseIter<T> for PriorityQueue<T> {
/// Visit all values in the underlying vector.
///
/// The values are **not** visited in order.
@ -35,7 +35,7 @@ impl <T: Ord> PriorityQueue<T>: BaseIter<T> {
pure fn size_hint(&self) -> Option<uint> { self.data.size_hint() }
}
impl <T: Ord> PriorityQueue<T>: Container {
impl<T: Ord> Container for PriorityQueue<T> {
/// Returns the length of the queue
pure fn len(&self) -> uint { self.data.len() }
@ -43,7 +43,7 @@ impl <T: Ord> PriorityQueue<T>: Container {
pure fn is_empty(&self) -> bool { self.data.is_empty() }
}
impl <T: Ord> PriorityQueue<T>: Mutable {
impl<T: Ord> Mutable for PriorityQueue<T> {
/// Drop all items from the queue
fn clear(&mut self) { self.data.truncate(0) }
}

2
src/libstd/sha1.rs
View file

@ -228,7 +228,7 @@ pub fn sha1() -> Sha1 {
process_msg_block(st);
}
impl Sha1State: Sha1 {
impl Sha1 for Sha1State {
fn reset(&mut self) {
assert (vec::len(self.h) == digest_buf_len);
self.len_low = 0u32;

10
src/libstd/smallintmap.rs
View file

@ -22,7 +22,7 @@ pub struct SmallIntMap<T> {
priv v: ~[Option<T>],
}
impl<V> SmallIntMap<V>: BaseIter<(uint, &V)> {
impl<V> BaseIter<(uint, &V)> for SmallIntMap<V> {
/// Visit all key-value pairs in order
pure fn each(&self, it: fn(&(uint, &self/V)) -> bool) {
for uint::range(0, self.v.len()) |i| {
@ -36,7 +36,7 @@ impl<V> SmallIntMap<V>: BaseIter<(uint, &V)> {
pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
impl<V> SmallIntMap<V>: ReverseIter<(uint, &V)> {
impl<V> ReverseIter<(uint, &V)> for SmallIntMap<V> {
/// Visit all key-value pairs in reverse order
pure fn each_reverse(&self, it: fn(&(uint, &self/V)) -> bool) {
for uint::range_rev(self.v.len(), 0) |i| {
@ -48,7 +48,7 @@ impl<V> SmallIntMap<V>: ReverseIter<(uint, &V)> {
}
}
impl<V> SmallIntMap<V>: Container {
impl<V> Container for SmallIntMap<V> {
/// Return the number of elements in the map
pure fn len(&self) -> uint {
let mut sz = 0;
@ -64,12 +64,12 @@ impl<V> SmallIntMap<V>: Container {
pure fn is_empty(&self) -> bool { self.len() == 0 }
}
impl<V> SmallIntMap<V>: Mutable {
impl<V> Mutable for SmallIntMap<V> {
/// Clear the map, removing all key-value pairs.
fn clear(&mut self) { self.v.clear() }
}
impl<V> SmallIntMap<V>: Map<uint, V> {
impl<V> Map<uint, V> for SmallIntMap<V> {
/// Return true if the map contains a value for the specified key
pure fn contains_key(&self, key: &uint) -> bool {
self.find(key).is_some()

10
src/libstd/sort.rs
View file

@ -169,7 +169,7 @@ pub trait Sort {
fn qsort(self);
}
impl<T: Copy Ord Eq> &mut [T] : Sort {
impl<T: Copy Ord Eq> Sort for &mut [T] {
fn qsort(self) { quick_sort3(self); }
}
@ -908,7 +908,7 @@ mod test_tim_sort {
val: float,
}
impl CVal: Ord {
impl Ord for CVal {
pure fn lt(&self, other: &CVal) -> bool {
unsafe {
let rng = rand::Rng();
@ -973,7 +973,7 @@ mod test_tim_sort {
struct DVal { val: uint }
impl DVal: Ord {
impl Ord for DVal {
pure fn lt(&self, _x: &DVal) -> bool { true }
pure fn le(&self, _x: &DVal) -> bool { true }
pure fn gt(&self, _x: &DVal) -> bool { true }
@ -1182,7 +1182,7 @@ mod big_tests {
}
impl LVal : Drop {
impl Drop for LVal {
fn finalize(&self) {
let x = unsafe { task::local_data::local_data_get(self.key) };
match x {
@ -1196,7 +1196,7 @@ mod big_tests {
}
}
impl LVal: Ord {
impl Ord for LVal {
pure fn lt(&self, other: &a/LVal/&self) -> bool {
(*self).val < other.val
}

2
src/libstd/stats.rs
View file

@ -30,7 +30,7 @@ pub trait Stats {
fn median_abs_dev_pct(self) -> f64;
}
impl &[f64] : Stats {
impl Stats for &[f64] {
fn sum(self) -> f64 {
vec::foldl(0.0, self, |p,q| p + *q)
}

20
src/libstd/sync.rs
View file

@ -167,7 +167,7 @@ type SemRelease = SemReleaseGeneric<()>;
type SemAndSignalRelease = SemReleaseGeneric<~[Waitqueue]>;
struct SemReleaseGeneric<Q> { sem: &Sem<Q> }
impl<Q: Owned> SemReleaseGeneric<Q> : Drop {
impl<Q: Owned> Drop for SemReleaseGeneric<Q> {
fn finalize(&self) {
self.sem.release();
}
@ -189,7 +189,7 @@ fn SemAndSignalRelease(sem: &r/Sem<~[Waitqueue]>)
/// A mechanism for atomic-unlock-and-deschedule blocking and signalling.
pub struct Condvar { priv sem: &Sem<~[Waitqueue]> }
impl Condvar : Drop { fn finalize(&self) {} }
impl Drop for Condvar { fn finalize(&self) {} }
impl &Condvar {
/**
@ -260,7 +260,7 @@ impl &Condvar {
sem: &Sem<~[Waitqueue]>,
}
impl SemAndSignalReacquire : Drop {
impl Drop for SemAndSignalReacquire {
fn finalize(&self) {
unsafe {
// Needs to succeed, instead of itself dying.
@ -362,7 +362,7 @@ pub fn semaphore(count: int) -> Semaphore {
Semaphore { sem: new_sem(count, ()) }
}
impl Semaphore: Clone {
impl Clone for Semaphore {
/// Create a new handle to the semaphore.
fn clone(&self) -> Semaphore {
Semaphore { sem: Sem((*self.sem).clone()) }
@ -412,7 +412,7 @@ pub fn mutex_with_condvars(num_condvars: uint) -> Mutex {
Mutex { sem: new_sem_and_signal(1, num_condvars) }
}
impl Mutex: Clone {
impl Clone for Mutex {
/// Create a new handle to the mutex.
fn clone(&self) -> Mutex { Mutex { sem: Sem((*self.sem).clone()) } }
}
@ -610,7 +610,7 @@ struct RWlockReleaseRead {
lock: &RWlock,
}
impl RWlockReleaseRead : Drop {
impl Drop for RWlockReleaseRead {
fn finalize(&self) {
unsafe {
do task::unkillable {
@ -644,7 +644,7 @@ struct RWlockReleaseDowngrade {
lock: &RWlock,
}
impl RWlockReleaseDowngrade : Drop {
impl Drop for RWlockReleaseDowngrade {
fn finalize(&self) {
unsafe {
do task::unkillable {
@ -682,10 +682,10 @@ fn RWlockReleaseDowngrade(lock: &r/RWlock) -> RWlockReleaseDowngrade/&r {
/// The "write permission" token used for rwlock.write_downgrade().
pub struct RWlockWriteMode { priv lock: &RWlock }
impl RWlockWriteMode : Drop { fn finalize(&self) {} }
impl Drop for RWlockWriteMode { fn finalize(&self) {} }
/// The "read permission" token used for rwlock.write_downgrade().
pub struct RWlockReadMode { priv lock: &RWlock }
impl RWlockReadMode : Drop { fn finalize(&self) {} }
impl Drop for RWlockReadMode { fn finalize(&self) {} }
impl &RWlockWriteMode {
/// Access the pre-downgrade rwlock in write mode.
@ -1007,7 +1007,7 @@ mod tests {
c: pipes::Chan<()>,
}
impl SendOnFailure : Drop {
impl Drop for SendOnFailure {
fn finalize(&self) {
self.c.send(());
}

6
src/libstd/time.rs
View file

@ -54,14 +54,14 @@ impl Timespec {
}
}
impl Timespec : Eq {
impl Eq for Timespec {
pure fn eq(&self, other: &Timespec) -> bool {
self.sec == other.sec && self.nsec == other.nsec
}
pure fn ne(&self, other: &Timespec) -> bool { !self.eq(other) }
}
impl Timespec : Ord {
impl Ord for Timespec {
pure fn lt(&self, other: &Timespec) -> bool {
self.sec < other.sec ||
(self.sec == other.sec && self.nsec < other.nsec)
@ -129,7 +129,7 @@ pub struct Tm {
tm_nsec: i32, // nanoseconds
}
impl Tm : Eq {
impl Eq for Tm {
pure fn eq(&self, other: &Tm) -> bool {
self.tm_sec == (*other).tm_sec &&
self.tm_min == (*other).tm_min &&

28
src/libstd/treemap.rs
View file

@ -39,7 +39,7 @@ pub struct TreeMap<K, V> {
priv length: uint
}
impl <K: Eq Ord, V: Eq> TreeMap<K, V>: Eq {
impl<K: Eq Ord, V: Eq> Eq for TreeMap<K, V> {
pure fn eq(&self, other: &TreeMap<K, V>) -> bool {
if self.len() != other.len() {
false
@ -85,7 +85,7 @@ pure fn lt<K: Ord, V>(a: &TreeMap<K, V>, b: &TreeMap<K, V>) -> bool {
return a_len < b_len;
}
impl <K: Ord, V> TreeMap<K, V>: Ord {
impl<K: Ord, V> Ord for TreeMap<K, V> {
#[inline(always)]
pure fn lt(&self, other: &TreeMap<K, V>) -> bool {
lt(self, other)
@ -104,7 +104,7 @@ impl <K: Ord, V> TreeMap<K, V>: Ord {
}
}
impl <K: Ord, V> TreeMap<K, V>: BaseIter<(&K, &V)> {
impl<K: Ord, V> BaseIter<(&K, &V)> for TreeMap<K, V> {
/// Visit all key-value pairs in order
pure fn each(&self, f: fn(&(&self/K, &self/V)) -> bool) {
each(&self.root, f)
@ -112,14 +112,14 @@ impl <K: Ord, V> TreeMap<K, V>: BaseIter<(&K, &V)> {
pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
impl <K: Ord, V> TreeMap<K, V>: ReverseIter<(&K, &V)> {
impl<K: Ord, V> ReverseIter<(&K, &V)> for TreeMap<K, V> {
/// Visit all key-value pairs in reverse order
pure fn each_reverse(&self, f: fn(&(&self/K, &self/V)) -> bool) {
each_reverse(&self.root, f);
}
}
impl <K: Ord, V> TreeMap<K, V>: Container {
impl<K: Ord, V> Container for TreeMap<K, V> {
/// Return the number of elements in the map
pure fn len(&self) -> uint { self.length }
@ -127,7 +127,7 @@ impl <K: Ord, V> TreeMap<K, V>: Container {
pure fn is_empty(&self) -> bool { self.root.is_none() }
}
impl <K: Ord, V> TreeMap<K, V>: Mutable {
impl<K: Ord, V> Mutable for TreeMap<K, V> {
/// Clear the map, removing all key-value pairs.
fn clear(&mut self) {
self.root = None;
@ -135,7 +135,7 @@ impl <K: Ord, V> TreeMap<K, V>: Mutable {
}
}
impl <K: Ord, V> TreeMap<K, V>: Map<K, V> {
impl<K: Ord, V> Map<K, V> for TreeMap<K, V> {
/// Return true if the map contains a value for the specified key
pure fn contains_key(&self, key: &K) -> bool {
self.find(key).is_some()
@ -246,25 +246,25 @@ pub struct TreeSet<T> {
priv map: TreeMap<T, ()>
}
impl <T: Ord> TreeSet<T>: BaseIter<T> {
impl<T: Ord> BaseIter<T> for TreeSet<T> {
/// Visit all values in order
pure fn each(&self, f: fn(&T) -> bool) { self.map.each_key(f) }
pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
impl <T: Ord> TreeSet<T>: ReverseIter<T> {
impl<T: Ord> ReverseIter<T> for TreeSet<T> {
/// Visit all values in reverse order
pure fn each_reverse(&self, f: fn(&T) -> bool) {
self.map.each_key_reverse(f)
}
}
impl <T: Eq Ord> TreeSet<T>: Eq {
impl<T: Eq Ord> Eq for TreeSet<T> {
pure fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
pure fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map }
}
impl <T: Ord> TreeSet<T>: Ord {
impl<T: Ord> Ord for TreeSet<T> {
#[inline(always)]
pure fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map }
#[inline(always)]
@ -275,7 +275,7 @@ impl <T: Ord> TreeSet<T>: Ord {
pure fn gt(&self, other: &TreeSet<T>) -> bool { self.map > other.map }
}
impl <T: Ord> TreeSet<T>: Container {
impl<T: Ord> Container for TreeSet<T> {
/// Return the number of elements in the set
pure fn len(&self) -> uint { self.map.len() }
@ -283,12 +283,12 @@ impl <T: Ord> TreeSet<T>: Container {
pure fn is_empty(&self) -> bool { self.map.is_empty() }
}
impl <T: Ord> TreeSet<T>: Mutable {
impl<T: Ord> Mutable for TreeSet<T> {
/// Clear the set, removing all values.
fn clear(&mut self) { self.map.clear() }
}
impl <T: Ord> TreeSet<T>: Set<T> {
impl<T: Ord> Set<T> for TreeSet<T> {
/// Return true if the set contains a value
pure fn contains(&self, value: &T) -> bool {
self.map.contains_key(value)

2
src/libstd/uv_global_loop.rs
View file

@ -51,7 +51,7 @@ fn get_monitor_task_gl() -> IoTask {
struct GlobalIoTask(IoTask);
impl GlobalIoTask: Clone {
impl Clone for GlobalIoTask {
fn clone(&self) -> GlobalIoTask {
GlobalIoTask((**self).clone())
}

2
src/libstd/uv_iotask.rs
View file

@ -31,7 +31,7 @@ pub struct IoTask {
op_chan: SharedChan<IoTaskMsg>
}
impl IoTask: Clone {
impl Clone for IoTask {
fn clone(&self) -> IoTask {
IoTask{
async_handle: self.async_handle,

6
src/libstd/workcache.rs
View file

@ -104,7 +104,7 @@ struct WorkKey {
name: ~str
}
impl WorkKey: to_bytes::IterBytes {
impl to_bytes::IterBytes for WorkKey {
#[inline(always)]
pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {
let mut flag = true;
@ -114,7 +114,7 @@ impl WorkKey: to_bytes::IterBytes {
}
}
impl WorkKey: cmp::Ord {
impl cmp::Ord for WorkKey {
pure fn lt(&self, other: &WorkKey) -> bool {
self.kind < other.kind ||
(self.kind == other.kind &&
@ -285,7 +285,7 @@ trait TPrep {
Decodable<json::Decoder>>(&self, blk: ~fn(&Exec) -> T) -> Work<T>;
}
impl @Mut<Prep> : TPrep {
impl TPrep for @Mut<Prep> {
fn declare_input(&self, kind:&str, name:&str, val:&str) {
do self.borrow_mut |p| {
p.declared_inputs.insert(WorkKey::new(kind, name),

2
src/libsyntax/attr.rs
View file

@ -326,7 +326,7 @@ pub enum inline_attr {
ia_never,
}
impl inline_attr : cmp::Eq {
impl cmp::Eq for inline_attr {
pure fn eq(&self, other: &inline_attr) -> bool {
((*self) as uint) == ((*other) as uint)
}

4
src/libsyntax/diagnostic.rs
View file

@ -63,7 +63,7 @@ struct CodemapT {
cm: @codemap::CodeMap,
}
impl CodemapT: span_handler {
impl span_handler for CodemapT {
fn span_fatal(@mut self, sp: span, msg: &str) -> ! {
self.handler.emit(Some((self.cm, sp)), msg, fatal);
fail!();
@ -89,7 +89,7 @@ impl CodemapT: span_handler {
}
}
impl HandlerT: handler {
impl handler for HandlerT {
fn fatal(@mut self, msg: &str) -> ! {
(self.emit)(None, msg, fatal);
fail!();

4
src/libsyntax/ext/auto_encode.rs
View file

@ -23,7 +23,7 @@ For example, a type like:
would generate two implementations like:
impl<S: std::serialize::Encoder> Node: Encodable<S> {
impl<S: std::serialize::Encoder> Encodable<S> for Node {
fn encode(&self, s: &S) {
do s.emit_struct("Node", 1) {
s.emit_field("id", 0, || s.emit_uint(self.id))
@ -31,7 +31,7 @@ impl<S: std::serialize::Encoder> Node: Encodable<S> {
}
}
impl<D: Decoder> node_id: Decodable {
impl<D: Decoder> Decodable for node_id {
static fn decode(d: &D) -> Node {
do d.read_struct("Node", 1) {
Node {

2
src/libsyntax/ext/base.rs
View file

@ -197,7 +197,7 @@ pub fn mk_ctxt(parse_sess: parse::parse_sess,
mod_path: ~[ast::ident],
trace_mac: bool
}
impl CtxtRepr: ext_ctxt {
impl ext_ctxt for CtxtRepr {
fn codemap(@mut self) -> @CodeMap { self.parse_sess.cm }
fn parse_sess(@mut self) -> parse::parse_sess { self.parse_sess }
fn cfg(@mut self) -> ast::crate_cfg { self.cfg }

32
src/libsyntax/ext/quote.rs
View file

@ -53,7 +53,7 @@ pub mod rt {
pub fn to_tokens(_cx: ext_ctxt) -> ~[token_tree];
}
impl ~[token_tree]: ToTokens {
impl ToTokens for ~[token_tree] {
pub fn to_tokens(_cx: ext_ctxt) -> ~[token_tree] {
copy self
}
@ -78,43 +78,43 @@ pub mod rt {
pub fn to_source(cx: ext_ctxt) -> ~str;
}
impl ast::ident: ToSource {
impl ToSource for ast::ident {
fn to_source(cx: ext_ctxt) -> ~str {
copy *cx.parse_sess().interner.get(self)
}
}
impl @ast::item: ToSource {
impl ToSource for @ast::item {
fn to_source(cx: ext_ctxt) -> ~str {
item_to_str(self, cx.parse_sess().interner)
}
}
impl ~[@ast::item]: ToSource {
impl ToSource for ~[@ast::item] {
fn to_source(cx: ext_ctxt) -> ~str {
str::connect(self.map(|i| i.to_source(cx)), ~"\n\n")
}
}
impl @ast::Ty: ToSource {
impl ToSource for @ast::Ty {
fn to_source(cx: ext_ctxt) -> ~str {
ty_to_str(self, cx.parse_sess().interner)
}
}
impl ~[@ast::Ty]: ToSource {
impl ToSource for ~[@ast::Ty] {
fn to_source(cx: ext_ctxt) -> ~str {
str::connect(self.map(|i| i.to_source(cx)), ~", ")
}
}
impl ~[ast::ty_param]: ToSource {
impl ToSource for ~[ast::ty_param] {
fn to_source(cx: ext_ctxt) -> ~str {
pprust::typarams_to_str(self, cx.parse_sess().interner)
}
}
impl @ast::expr: ToSource {
impl ToSource for @ast::expr {
fn to_source(cx: ext_ctxt) -> ~str {
pprust::expr_to_str(self, cx.parse_sess().interner)
}
@ -122,43 +122,43 @@ pub mod rt {
// Alas ... we write these out instead. All redundant.
impl ast::ident: ToTokens {
impl ToTokens for ast::ident {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
}
impl @ast::item: ToTokens {
impl ToTokens for @ast::item {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
}
impl ~[@ast::item]: ToTokens {
impl ToTokens for ~[@ast::item] {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
}
impl @ast::Ty: ToTokens {
impl ToTokens for @ast::Ty {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
}
impl ~[@ast::Ty]: ToTokens {
impl ToTokens for ~[@ast::Ty] {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
}
impl ~[ast::ty_param]: ToTokens {
impl ToTokens for ~[ast::ty_param] {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
}
impl @ast::expr: ToTokens {
impl ToTokens for @ast::expr {
fn to_tokens(cx: ext_ctxt) -> ~[token_tree] {
cx.parse_tts(self.to_source(cx))
}
@ -171,7 +171,7 @@ pub mod rt {
fn parse_tts(s: ~str) -> ~[ast::token_tree];
}
impl ext_ctxt: ExtParseUtils {
impl ExtParseUtils for ext_ctxt {
fn parse_item(s: ~str) -> @ast::item {
let res = parse::parse_item_from_source_str(

2
src/libsyntax/parse/attr.rs
View file

@ -30,7 +30,7 @@ pub trait parser_attr {
fn parse_optional_meta() -> ~[@ast::meta_item];
}
impl Parser: parser_attr {
impl parser_attr for Parser {
// Parse attributes that appear before an item
fn parse_outer_attributes() -> ~[ast::attribute] {

2
src/libsyntax/parse/comments.rs
View file

@ -34,7 +34,7 @@ pub enum cmnt_style {
blank_line, // Just a manual blank line "\n\n", for layout
}
impl cmnt_style : cmp::Eq {
impl cmp::Eq for cmnt_style {
pure fn eq(&self, other: &cmnt_style) -> bool {
((*self) as uint) == ((*other) as uint)
}

2
src/libsyntax/parse/lexer.rs
View file

@ -108,7 +108,7 @@ fn dup_string_reader(r: @mut StringReader) -> @mut StringReader {
}
}
impl StringReader: reader {
impl reader for StringReader {
fn is_eof(@mut self) -> bool { is_eof(self) }
// return the next token. EFFECT: advances the string_reader.
fn next_token(@mut self) -> TokenAndSpan {

2
src/libsyntax/parse/token.rs
View file

@ -520,7 +520,7 @@ pub fn reserved_keyword_table() -> HashMap<~str, ()> {
}
impl Token : cmp::Eq {
impl cmp::Eq for Token {
pure fn eq(&self, other: &Token) -> bool {
match (*self) {
EQ => {

2
src/test/auxiliary/ambig_impl_2_lib.rs
View file

@ -11,4 +11,4 @@
trait me {
fn me() -> uint;
}
impl uint: me { fn me() -> uint { self } }
impl me for uint { fn me() -> uint { self } }

2
src/test/auxiliary/cci_impl_lib.rs
View file

@ -14,7 +14,7 @@ trait uint_helpers {
fn to(v: uint, f: fn(uint));
}
impl uint: uint_helpers {
impl uint_helpers for uint {
#[inline]
fn to(v: uint, f: fn(uint)) {
let mut i = self;

2
src/test/auxiliary/explicit_self_xcrate.rs
View file

@ -17,7 +17,7 @@ pub struct Bar {
x: ~str
}
impl Bar : Foo {
impl Foo for Bar {
#[inline(always)]
fn f(&self) {
io::println((*self).x);

2
src/test/auxiliary/impl_privacy_xc_2.rs
View file

@ -6,7 +6,7 @@ pub struct Fish {
mod unexported {
use super::Fish;
impl Fish : Eq {
impl Eq for Fish {
pure fn eq(&self, _: &Fish) -> bool { true }
pure fn ne(&self, _: &Fish) -> bool { false }
}

2
src/test/auxiliary/issue-2380.rs
View file

@ -14,7 +14,7 @@
pub trait i<T> { }
pub fn f<T>() -> i<T> {
impl<T> (): i<T> { }
impl<T> i<T> for () { }
() as i::<T>
}

2
src/test/auxiliary/issue-2414-a.rs
View file

@ -17,7 +17,7 @@ trait foo {
fn foo();
}
impl ~str: foo {
impl foo for ~str {
fn foo() {}
}

4
src/test/auxiliary/issue-2526.rs
View file

@ -19,7 +19,7 @@ struct arc_destruct<T> {
_data: int,
}
impl<T:Const> arc_destruct<T> : Drop {
impl<T:Const> Drop for arc_destruct<T> {
fn finalize(&self) {}
}
@ -43,7 +43,7 @@ struct context_res {
ctx : int,
}
impl context_res : Drop {
impl Drop for context_res {
fn finalize(&self) {}
}

Some files were not shown because too many files have changed in this diff Show more