auto merge of #5233 : bstrie/rust/deimpselfcore, r=graydon

19 files changed, 338 insertions, 315 deletions

diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index 6c35c62c3a7..a85ab1a29b7 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -30,7 +30,7 @@ pub pure fn empty_cell<T>() -> Cell<T> {
 
 pub impl<T> Cell<T> {
     /// Yields the value, failing if the cell is empty.
-    fn take() -> T {
+    fn take(&self) -> T {
         if self.is_empty() {
             fail!(~"attempt to take an empty cell");
         }
@@ -41,7 +41,7 @@ pub impl<T> Cell<T> {
     }
 
     /// Returns the value, failing if the cell is full.
-    fn put_back(value: T) {
+    fn put_back(&self, value: T) {
         if !self.is_empty() {
             fail!(~"attempt to put a value back into a full cell");
         }
@@ -49,12 +49,12 @@ pub impl<T> Cell<T> {
     }
 
     /// Returns true if the cell is empty and false if the cell is full.
-    pure fn is_empty() -> bool {
+    pure fn is_empty(&self) -> bool {
         self.value.is_none()
     }
 
     // Calls a closure with a reference to the value.
-    fn with_ref<R>(op: fn(v: &T) -> R) -> R {
+    fn with_ref<R>(&self, op: fn(v: &T) -> R) -> R {
         let v = self.take();
         let r = op(&v);
         self.put_back(v);
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index 94272f63e67..4f812a5ae76 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -24,31 +24,31 @@ pub use pipes::Selectable;
 /// A trait for things that can send multiple messages.
 pub trait GenericChan<T> {
     /// Sends a message.
-    fn send(x: T);
+    fn send(&self, x: T);
 }
 
 /// Things that can send multiple messages and can detect when the receiver
 /// is closed
 pub trait GenericSmartChan<T> {
     /// Sends a message, or report if the receiver has closed the connection.
-    fn try_send(x: T) -> bool;
+    fn try_send(&self, x: T) -> bool;
 }
 
 /// A trait for things that can receive multiple messages.
 pub trait GenericPort<T> {
     /// Receives a message, or fails if the connection closes.
-    fn recv() -> T;
+    fn recv(&self) -> T;
 
     /** Receives a message, or returns `none` if
     the connection is closed or closes.
     */
-    fn try_recv() -> Option<T>;
+    fn try_recv(&self) -> Option<T>;
 }
 
 /// Ports that can `peek`
 pub trait Peekable<T> {
     /// Returns true if a message is available
-    pure fn peek() -> bool;
+    pure fn peek(&self) -> bool;
 }
 
 /// Returns the index of an endpoint that is ready to receive.
@@ -105,7 +105,7 @@ pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
 }
 
 impl<T: Owned> GenericChan<T> for Chan<T> {
-    fn send(x: T) {
+    fn send(&self, x: T) {
         let mut endp = None;
         endp <-> self.endp;
         self.endp = Some(
@@ -115,7 +115,7 @@ impl<T: Owned> GenericChan<T> for Chan<T> {
 
 impl<T: Owned> GenericSmartChan<T> for Chan<T> {
 
-    fn try_send(x: T) -> bool {
+    fn try_send(&self, x: T) -> bool {
         let mut endp = None;
         endp <-> self.endp;
         match streamp::client::try_data(unwrap(endp), x) {
@@ -129,7 +129,7 @@ impl<T: Owned> GenericSmartChan<T> for Chan<T> {
 }
 
 impl<T: Owned> GenericPort<T> for Port<T> {
-    fn recv() -> T {
+    fn recv(&self) -> T {
         let mut endp = None;
         endp <-> self.endp;
         let streamp::data(x, endp) = recv(unwrap(endp));
@@ -137,7 +137,7 @@ impl<T: Owned> GenericPort<T> for Port<T> {
         x
     }
 
-    fn try_recv() -> Option<T> {
+    fn try_recv(&self) -> Option<T> {
         let mut endp = None;
         endp <-> self.endp;
         match try_recv(unwrap(endp)) {
@@ -151,7 +151,7 @@ impl<T: Owned> GenericPort<T> for Port<T> {
 }
 
 impl<T: Owned> Peekable<T> for Port<T> {
-    pure fn peek() -> bool {
+    pure fn peek(&self) -> bool {
         unsafe {
             let mut endp = None;
             endp <-> self.endp;
@@ -166,7 +166,7 @@ impl<T: Owned> Peekable<T> for Port<T> {
 }
 
 impl<T: Owned> Selectable for Port<T> {
-    pure fn header() -> *PacketHeader {
+    pure fn header(&self) -> *PacketHeader {
         unsafe {
             match self.endp {
               Some(ref endp) => endp.header(),
@@ -189,11 +189,11 @@ pub fn PortSet<T: Owned>() -> PortSet<T>{
 
 pub impl<T: Owned> PortSet<T> {
 
-    fn add(port: Port<T>) {
+    fn add(&self, port: Port<T>) {
         self.ports.push(port)
     }
 
-    fn chan() -> Chan<T> {
+    fn chan(&self) -> Chan<T> {
         let (po, ch) = stream();
         self.add(po);
         ch
@@ -202,7 +202,7 @@ pub impl<T: Owned> PortSet<T> {
 
 impl<T: Owned> GenericPort<T> for PortSet<T> {
 
-    fn try_recv() -> Option<T> {
+    fn try_recv(&self) -> Option<T> {
         let mut result = None;
         // we have to swap the ports array so we aren't borrowing
         // aliasable mutable memory.
@@ -224,14 +224,14 @@ impl<T: Owned> GenericPort<T> for PortSet<T> {
         result
     }
 
-    fn recv() -> T {
+    fn recv(&self) -> T {
         self.try_recv().expect("port_set: endpoints closed")
     }
 
 }
 
 impl<T: Owned> Peekable<T> for PortSet<T> {
-    pure fn peek() -> bool {
+    pure fn peek(&self) -> bool {
         // It'd be nice to use self.port.each, but that version isn't
         // pure.
         for vec::each(self.ports) |p| {
@@ -245,7 +245,7 @@ impl<T: Owned> Peekable<T> for PortSet<T> {
 pub type SharedChan<T> = unstable::Exclusive<Chan<T>>;
 
 impl<T: Owned> GenericChan<T> for SharedChan<T> {
-    fn send(x: T) {
+    fn send(&self, x: T) {
         let mut xx = Some(x);
         do self.with_imm |chan| {
             let mut x = None;
@@ -256,7 +256,7 @@ impl<T: Owned> GenericChan<T> for SharedChan<T> {
 }
 
 impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
-    fn try_send(x: T) -> bool {
+    fn try_send(&self, x: T) -> bool {
         let mut xx = Some(x);
         do self.with_imm |chan| {
             let mut x = None;
@@ -274,9 +274,9 @@ pub fn SharedChan<T:Owned>(c: Chan<T>) -> SharedChan<T> {
 /// Receive a message from one of two endpoints.
 pub trait Select2<T: Owned, U: Owned> {
     /// Receive a message or return `None` if a connection closes.
-    fn try_select() -> Either<Option<T>, Option<U>>;
+    fn try_select(&self) -> Either<Option<T>, Option<U>>;
     /// Receive a message or fail if a connection closes.
-    fn select() -> Either<T, U>;
+    fn select(&self) -> Either<T, U>;
 }
 
 impl<T: Owned, U: Owned,
@@ -284,8 +284,8 @@ impl<T: Owned, U: Owned,
      Right: Selectable + GenericPort<U>>
     Select2<T, U> for (Left, Right) {
 
-    fn select() -> Either<T, U> {
-        match self {
+    fn select(&self) -> Either<T, U> {
+        match *self {
           (ref lp, ref rp) => match select2i(lp, rp) {
             Left(()) => Left (lp.recv()),
             Right(()) => Right(rp.recv())
@@ -293,8 +293,8 @@ impl<T: Owned, U: Owned,
         }
     }
 
-    fn try_select() -> Either<Option<T>, Option<U>> {
-        match self {
+    fn try_select(&self) -> Either<Option<T>, Option<U>> {
+        match *self {
           (ref lp, ref rp) => match select2i(lp, rp) {
             Left(()) => Left (lp.try_recv()),
             Right(()) => Right(rp.try_recv())
diff --git a/src/libcore/condition.rs b/src/libcore/condition.rs
index 00048beae5a..87752cff1bf 100644
--- a/src/libcore/condition.rs
+++ b/src/libcore/condition.rs
@@ -35,12 +35,12 @@ pub impl<T, U> Condition<T, U> {
         }
     }
 
-    fn raise(t: T) -> U {
+    fn raise(&self, t: T) -> U {
         let msg = fmt!("Unhandled condition: %s: %?", self.name, t);
         self.raise_default(t, || fail!(copy msg))
     }
 
-    fn raise_default(t: T, default: &fn() -> U) -> U {
+    fn raise_default(&self, t: T, default: &fn() -> U) -> U {
         unsafe {
             match local_data_pop(self.key) {
                 None => {
diff --git a/src/libcore/dlist.rs b/src/libcore/dlist.rs
index f1f4e558661..34a3c3e60af 100644
--- a/src/libcore/dlist.rs
+++ b/src/libcore/dlist.rs
@@ -148,7 +148,7 @@ priv impl<T> DList<T> {
             fail!(~"That node isn't on this dlist.")
         }
     }
-    fn make_mine(nobe: @mut DListNode<T>) {
+    fn make_mine(&self, nobe: @mut DListNode<T>) {
         if nobe.prev.is_some() || nobe.next.is_some() || nobe.linked {
             fail!(~"Cannot insert node that's already on a dlist!")
         }
diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs
index 5ec0dd073c8..7eb615d07a6 100644
--- a/src/libcore/dvec.rs
+++ b/src/libcore/dvec.rs
@@ -82,7 +82,7 @@ pub pure fn unwrap<A>(d: DVec<A>) -> ~[A] {
 
 priv impl<A> DVec<A> {
     #[inline(always)]
-    pure fn check_not_borrowed() {
+    pure fn check_not_borrowed(&self) {
         unsafe {
             let data: *() = cast::reinterpret_cast(&self.data);
             if data.is_null() {
@@ -92,7 +92,7 @@ priv impl<A> DVec<A> {
     }
 
     #[inline(always)]
-    fn give_back(data: ~[A]) {
+    fn give_back(&self, data: ~[A]) {
         unsafe {
             self.data = data;
         }
@@ -119,7 +119,7 @@ pub impl<A> DVec<A> {
     }
 
     /// Reserves space for N elements
-    fn reserve(count: uint) {
+    fn reserve(&self, count: uint) {
         vec::reserve(&mut self.data, count)
     }
 
@@ -129,26 +129,26 @@ pub impl<A> DVec<A> {
      * and return a new vector to replace it with.
      */
     #[inline(always)]
-    fn swap(f: &fn(v: ~[A]) -> ~[A]) {
+    fn swap(&self, f: &fn(v: ~[A]) -> ~[A]) {
         self.check_out(|v| self.give_back(f(v)))
     }
 
     /// Returns the number of elements currently in the dvec
     #[inline(always)]
-    pure fn len() -> uint {
+    pure fn len(&self) -> uint {
         self.check_not_borrowed();
         return self.data.len();
     }
 
     /// Overwrite the current contents
     #[inline(always)]
-    fn set(w: ~[A]) {
+    fn set(&self, w: ~[A]) {
         self.check_not_borrowed();
         self.data = w;
     }
 
     /// Remove and return the last element
-    fn pop() -> A {
+    fn pop(&self) -> A {
         do self.check_out |v| {
             let mut v = v;
             let result = v.pop();
@@ -158,7 +158,7 @@ pub impl<A> DVec<A> {
     }
 
     /// Insert a single item at the front of the list
-    fn unshift(t: A) {
+    fn unshift(&self, t: A) {
         unsafe {
             let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
@@ -171,13 +171,13 @@ pub impl<A> DVec<A> {
 
     /// Append a single item to the end of the list
     #[inline(always)]
-    fn push(t: A) {
+    fn push(&self, t: A) {
         self.check_not_borrowed();
         self.data.push(t);
     }
 
     /// Remove and return the first element
-    fn shift() -> A {
+    fn shift(&self) -> A {
         do self.check_out |v| {
             let mut v = v;
             let result = v.shift();
@@ -187,7 +187,7 @@ pub impl<A> DVec<A> {
     }
 
     /// Reverse the elements in the list, in place
-    fn reverse() {
+    fn reverse(&self) {
         do self.check_out |v| {
             let mut v = v;
             vec::reverse(v);
@@ -196,7 +196,7 @@ pub impl<A> DVec<A> {
     }
 
     /// Gives access to the vector as a slice with immutable contents
-    fn borrow<R>(op: fn(x: &[A]) -> R) -> R {
+    fn borrow<R>(&self, op: fn(x: &[A]) -> R) -> R {
         do self.check_out |v| {
             let result = op(v);
             self.give_back(v);
@@ -205,7 +205,7 @@ pub impl<A> DVec<A> {
     }
 
     /// Gives access to the vector as a slice with mutable contents
-    fn borrow_mut<R>(op: &fn(x: &mut [A]) -> R) -> R {
+    fn borrow_mut<R>(&self, op: &fn(x: &mut [A]) -> R) -> R {
         do self.check_out |v| {
             let mut v = v;
             let result = op(v);
@@ -221,12 +221,12 @@ pub impl<A:Copy> DVec<A> {
      *
      * Equivalent to `append_iter()` but potentially more efficient.
      */
-    fn push_all(ts: &[const A]) {
+    fn push_all(&self, ts: &[const A]) {
         self.push_slice(ts, 0u, vec::len(ts));
     }
 
     /// Appends elements from `from_idx` to `to_idx` (exclusive)
-    fn push_slice(ts: &[const A], from_idx: uint, to_idx: uint) {
+    fn push_slice(&self, ts: &[const A], from_idx: uint, to_idx: uint) {
         do self.swap |v| {
             let mut v = v;
             let new_len = vec::len(v) + to_idx - from_idx;
@@ -270,7 +270,7 @@ pub impl<A:Copy> DVec<A> {
      *
      * See `unwrap()` if you do not wish to copy the contents.
      */
-    pure fn get() -> ~[A] {
+    pure fn get(&self) -> ~[A] {
         unsafe {
             do self.check_out |v| {
                 let w = copy v;
@@ -282,13 +282,13 @@ pub impl<A:Copy> DVec<A> {
 
     /// Copy out an individual element
     #[inline(always)]
-    pure fn get_elt(idx: uint) -> A {
+    pure fn get_elt(&self, idx: uint) -> A {
         self.check_not_borrowed();
         return self.data[idx];
     }
 
     /// Overwrites the contents of the element at `idx` with `a`
-    fn set_elt(idx: uint, a: A) {
+    fn set_elt(&self, idx: uint, a: A) {
         self.check_not_borrowed();
         self.data[idx] = a;
     }
@@ -298,7 +298,7 @@ pub impl<A:Copy> DVec<A> {
      * growing the vector if necessary.  New elements will be initialized
      * with `initval`
      */
-    fn grow_set_elt(idx: uint, initval: &A, val: A) {
+    fn grow_set_elt(&self, idx: uint, initval: &A, val: A) {
         do self.swap |v| {
             let mut v = v;
             v.grow_set(idx, initval, val);
@@ -308,7 +308,7 @@ pub impl<A:Copy> DVec<A> {
 
     /// Returns the last element, failing if the vector is empty
     #[inline(always)]
-    pure fn last() -> A {
+    pure fn last(&self) -> A {
         self.check_not_borrowed();
 
         let length = self.len();
@@ -321,7 +321,7 @@ pub impl<A:Copy> DVec<A> {
 
     /// Iterates over the elements in reverse order
     #[inline(always)]
-    fn rev_each(f: fn(v: &A) -> bool) {
+    fn rev_each(&self, f: fn(v: &A) -> bool) {
         do self.swap |v| {
             // FIXME(#2263)---we should be able to write
             // `vec::rev_each(v, f);` but we cannot write now
@@ -334,7 +334,7 @@ pub impl<A:Copy> DVec<A> {
 
     /// Iterates over the elements and indices in reverse order
     #[inline(always)]
-    fn rev_eachi(f: fn(uint, v: &A) -> bool) {
+    fn rev_eachi(&self, f: fn(uint, v: &A) -> bool) {
         do self.swap |v| {
             // FIXME(#2263)---we should be able to write
             // `vec::rev_eachi(v, f);` but we cannot write now
diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs
index a6048e2b25a..2587b84b274 100644
--- a/src/libcore/hash.rs
+++ b/src/libcore/hash.rs
@@ -50,32 +50,32 @@ pub trait Hash {
      * function and require most types to only implement the
      * IterBytes trait, that feeds SipHash.
      */
-    pure fn hash_keyed(k0: u64, k1: u64) -> u64;
+    pure fn hash_keyed(&self, k0: u64, k1: u64) -> u64;
 }
 
 // When we have default methods, won't need this.
 pub trait HashUtil {
-    pure fn hash() -> u64;
+    pure fn hash(&self) -> u64;
 }
 
 impl<A:Hash> HashUtil for A {
     #[inline(always)]
-    pure fn hash() -> u64 { self.hash_keyed(0,0) }
+    pure fn hash(&self) -> u64 { self.hash_keyed(0,0) }
 }
 
 /// Streaming hash-functions should implement this.
 pub trait Streaming {
-    fn input((&[const u8]));
+    fn input(&self, (&[const u8]));
     // These can be refactored some when we have default methods.
-    fn result_bytes() -> ~[u8];
+    fn result_bytes(&self) -> ~[u8];
     fn result_str() -> ~str;
-    fn result_u64() -> u64;
-    fn reset();
+    fn result_u64(&self) -> u64;
+    fn reset(&self);
 }
 
 impl<A:IterBytes> Hash for A {
     #[inline(always)]
-    pure fn hash_keyed(k0: u64, k1: u64) -> u64 {
+    pure fn hash_keyed(&self, k0: u64, k1: u64) -> u64 {
         unsafe {
             let s = &State(k0, k1);
             for self.iter_bytes(true) |bytes| {
@@ -301,12 +301,12 @@ impl io::Writer for SipState {
 impl Streaming for &SipState {
 
     #[inline(always)]
-    fn input(buf: &[const u8]) {
+    fn input(&self, buf: &[const u8]) {
         self.write(buf);
     }
 
     #[inline(always)]
-    fn result_u64() -> u64 {
+    fn result_u64(&self) -> u64 {
         let mut v0 = self.v0;
         let mut v1 = self.v1;
         let mut v2 = self.v2;
@@ -336,7 +336,7 @@ impl Streaming for &SipState {
         return (v0 ^ v1 ^ v2 ^ v3);
     }
 
-    fn result_bytes() -> ~[u8] {
+    fn result_bytes(&self) -> ~[u8] {
         let h = self.result_u64();
         ~[(h >> 0) as u8,
           (h >> 8) as u8,
@@ -349,6 +349,7 @@ impl Streaming for &SipState {
         ]
     }
 
+    // IMPLICIT SELF WARNING: fix me!
     fn result_str() -> ~str {
         let r = self.result_bytes();
         let mut s = ~"";
@@ -359,7 +360,7 @@ impl Streaming for &SipState {
     }
 
     #[inline(always)]
-    fn reset() {
+    fn reset(&self) {
         self.length = 0;
         self.v0 = self.k0 ^ 0x736f6d6570736575;
         self.v1 = self.k1 ^ 0x646f72616e646f6d;
diff --git a/src/libcore/mutable.rs b/src/libcore/mutable.rs
index f888fbdb40c..e4b8d204dd7 100644
--- a/src/libcore/mutable.rs
+++ b/src/libcore/mutable.rs
@@ -44,7 +44,7 @@ pub fn unwrap<T>(m: Mut<T>) -> T {
 }
 
 pub impl<T> Data<T> {
-    fn borrow_mut<R>(op: &fn(t: &mut T) -> R) -> R {
+    fn borrow_mut<R>(&self, op: &fn(t: &mut T) -> R) -> R {
         match self.mode {
             Immutable => fail!(fmt!("%? currently immutable",
                                    self.value)),
@@ -56,11 +56,11 @@ pub impl<T> Data<T> {
         }
     }
 
-    pure fn borrow_const<R>(op: &fn(t: &const T) -> R) -> R {
+    pure fn borrow_const<R>(&self, op: &fn(t: &const T) -> R) -> R {
         op(&const self.value)
     }
 
-    fn borrow_imm<R>(op: &fn(t: &T) -> R) -> R {
+    fn borrow_imm<R>(&self, op: &fn(t: &T) -> R) -> R {
         match self.mode {
           Mutable => fail!(fmt!("%? currently mutable",
                                self.value)),
diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index a88c779d808..eed6e8540f0 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -45,28 +45,28 @@ pub pure fn PosixPath(s: &str) -> PosixPath {
 pub trait GenericPath {
     static pure fn from_str(&str) -> Self;
 
-    pure fn dirname() -> ~str;
-    pure fn filename() -> Option<~str>;
-    pure fn filestem() -> Option<~str>;
-    pure fn filetype() -> Option<~str>;
+    pure fn dirname(&self) -> ~str;
+    pure fn filename(&self) -> Option<~str>;
+    pure fn filestem(&self) -> Option<~str>;
+    pure fn filetype(&self) -> Option<~str>;
 
-    pure fn with_dirname((&str)) -> Self;
-    pure fn with_filename((&str)) -> Self;
-    pure fn with_filestem((&str)) -> Self;
-    pure fn with_filetype((&str)) -> Self;
+    pure fn with_dirname(&self, (&str)) -> Self;
+    pure fn with_filename(&self, (&str)) -> Self;
+    pure fn with_filestem(&self, (&str)) -> Self;
+    pure fn with_filetype(&self, (&str)) -> Self;
 
-    pure fn dir_path() -> Self;
-    pure fn file_path() -> Self;
+    pure fn dir_path(&self) -> Self;
+    pure fn file_path(&self) -> Self;
 
-    pure fn push((&str)) -> Self;
-    pure fn push_rel((&Self)) -> Self;
-    pure fn push_many((&[~str])) -> Self;
-    pure fn pop() -> Self;
+    pure fn push(&self, (&str)) -> Self;
+    pure fn push_rel(&self, (&Self)) -> Self;
+    pure fn push_many(&self, (&[~str])) -> Self;
+    pure fn pop(&self) -> Self;
 
-    pure fn unsafe_join((&Self)) -> Self;
-    pure fn is_restricted() -> bool;
+    pure fn unsafe_join(&self, (&Self)) -> Self;
+    pure fn is_restricted(&self) -> bool;
 
-    pure fn normalize() -> Self;
+    pure fn normalize(&self) -> Self;
 }
 
 #[cfg(windows)]
@@ -387,7 +387,7 @@ impl GenericPath for PosixPath {
                            components: components }
     }
 
-    pure fn dirname() -> ~str {
+    pure fn dirname(&self) -> ~str {
         unsafe {
             let s = self.dir_path().to_str();
             if s.len() == 0 {
@@ -398,14 +398,14 @@ impl GenericPath for PosixPath {
         }
     }
 
-    pure fn filename() -> Option<~str> {
+    pure fn filename(&self) -> Option<~str> {
         match self.components.len() {
           0 => None,
           n => Some(copy self.components[n - 1])
         }
     }
 
-    pure fn filestem() -> Option<~str> {
+    pure fn filestem(&self) -> Option<~str> {
         match self.filename() {
           None => None,
           Some(ref f) => {
@@ -417,7 +417,7 @@ impl GenericPath for PosixPath {
         }
     }
 
-    pure fn filetype() -> Option<~str> {
+    pure fn filetype(&self) -> Option<~str> {
         match self.filename() {
           None => None,
           Some(ref f) => {
@@ -429,7 +429,7 @@ impl GenericPath for PosixPath {
         }
     }
 
-    pure fn with_dirname(d: &str) -> PosixPath {
+    pure fn with_dirname(&self, d: &str) -> PosixPath {
         let dpath = PosixPath(d);
         match self.filename() {
           Some(ref f) => dpath.push(*f),
@@ -437,24 +437,24 @@ impl GenericPath for PosixPath {
         }
     }
 
-    pure fn with_filename(f: &str) -> PosixPath {
+    pure fn with_filename(&self, f: &str) -> PosixPath {
         unsafe {
             assert ! str::any(f, |c| windows::is_sep(c as u8));
             self.dir_path().push(f)
         }
     }
 
-    pure fn with_filestem(s: &str) -> PosixPath {
+    pure fn with_filestem(&self, s: &str) -> PosixPath {
         match self.filetype() {
           None => self.with_filename(s),
           Some(ref t) => self.with_filename(str::from_slice(s) + *t)
         }
     }
 
-    pure fn with_filetype(t: &str) -> PosixPath {
+    pure fn with_filetype(&self, t: &str) -> PosixPath {
         if t.len() == 0 {
             match self.filestem() {
-              None => copy self,
+              None => copy *self,
               Some(ref s) => self.with_filename(*s)
             }
         } else {
@@ -466,15 +466,15 @@ impl GenericPath for PosixPath {
         }
     }
 
-    pure fn dir_path() -> PosixPath {
+    pure fn dir_path(&self) -> PosixPath {
         if self.components.len() != 0 {
             self.pop()
         } else {
-            copy self
+            copy *self
         }
     }
 
-    pure fn file_path() -> PosixPath {
+    pure fn file_path(&self) -> PosixPath {
         let cs = match self.filename() {
           None => ~[],
           Some(ref f) => ~[copy *f]
@@ -483,12 +483,12 @@ impl GenericPath for PosixPath {
                            components: cs }
     }
 
-    pure fn push_rel(other: &PosixPath) -> PosixPath {
+    pure fn push_rel(&self, other: &PosixPath) -> PosixPath {
         assert !other.is_absolute;
         self.push_many(other.components)
     }
 
-    pure fn unsafe_join(other: &PosixPath) -> PosixPath {
+    pure fn unsafe_join(&self, other: &PosixPath) -> PosixPath {
         if other.is_absolute {
             PosixPath { is_absolute: true,
                         components: copy other.components }
@@ -497,11 +497,11 @@ impl GenericPath for PosixPath {
         }
     }
 
-    pure fn is_restricted() -> bool {
+    pure fn is_restricted(&self) -> bool {
         false
     }
 
-    pure fn push_many(cs: &[~str]) -> PosixPath {
+    pure fn push_many(&self, cs: &[~str]) -> PosixPath {
         let mut v = copy self.components;
         for cs.each |e| {
             let mut ss = str::split_nonempty(
@@ -513,14 +513,14 @@ impl GenericPath for PosixPath {
                     components: v }
     }
 
-    pure fn push(s: &str) -> PosixPath {
+    pure fn push(&self, s: &str) -> PosixPath {
         let mut v = copy self.components;
         let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
         unsafe { v.push_all_move(ss); }
-        PosixPath { components: v, ..copy self }
+        PosixPath { components: v, ..copy *self }
     }
 
-    pure fn pop() -> PosixPath {
+    pure fn pop(&self) -> PosixPath {
         let mut cs = copy self.components;
         if cs.len() != 0 {
             unsafe { cs.pop(); }
@@ -532,7 +532,7 @@ impl GenericPath for PosixPath {
                           //..self }
     }
 
-    pure fn normalize() -> PosixPath {
+    pure fn normalize(&self) -> PosixPath {
         return PosixPath {
             is_absolute: self.is_absolute,
             components: normalize(self.components)
@@ -599,7 +599,7 @@ impl GenericPath for WindowsPath {
                              components: components }
     }
 
-    pure fn dirname() -> ~str {
+    pure fn dirname(&self) -> ~str {
         unsafe {
             let s = self.dir_path().to_str();
             if s.len() == 0 {
@@ -610,14 +610,14 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn filename() -> Option<~str> {
+    pure fn filename(&self) -> Option<~str> {
         match self.components.len() {
           0 => None,
           n => Some(copy self.components[n - 1])
         }
     }
 
-    pure fn filestem() -> Option<~str> {
+    pure fn filestem(&self) -> Option<~str> {
         match self.filename() {
           None => None,
           Some(ref f) => {
@@ -629,7 +629,7 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn filetype() -> Option<~str> {
+    pure fn filetype(&self) -> Option<~str> {
         match self.filename() {
           None => None,
           Some(ref f) => {
@@ -641,7 +641,7 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn with_dirname(d: &str) -> WindowsPath {
+    pure fn with_dirname(&self, d: &str) -> WindowsPath {
         let dpath = WindowsPath(d);
         match self.filename() {
           Some(ref f) => dpath.push(*f),
@@ -649,22 +649,22 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn with_filename(f: &str) -> WindowsPath {
+    pure fn with_filename(&self, f: &str) -> WindowsPath {
         assert ! str::any(f, |c| windows::is_sep(c as u8));
         self.dir_path().push(f)
     }
 
-    pure fn with_filestem(s: &str) -> WindowsPath {
+    pure fn with_filestem(&self, s: &str) -> WindowsPath {
         match self.filetype() {
           None => self.with_filename(s),
           Some(ref t) => self.with_filename(str::from_slice(s) + *t)
         }
     }
 
-    pure fn with_filetype(t: &str) -> WindowsPath {
+    pure fn with_filetype(&self, t: &str) -> WindowsPath {
         if t.len() == 0 {
             match self.filestem() {
-              None => copy self,
+              None => copy *self,
               Some(ref s) => self.with_filename(*s)
             }
         } else {
@@ -677,15 +677,15 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn dir_path() -> WindowsPath {
+    pure fn dir_path(&self) -> WindowsPath {
         if self.components.len() != 0 {
             self.pop()
         } else {
-            copy self
+            copy *self
         }
     }
 
-    pure fn file_path() -> WindowsPath {
+    pure fn file_path(&self) -> WindowsPath {
         let cs = match self.filename() {
           None => ~[],
           Some(ref f) => ~[copy *f]
@@ -696,12 +696,12 @@ impl GenericPath for WindowsPath {
                              components: cs }
     }
 
-    pure fn push_rel(other: &WindowsPath) -> WindowsPath {
+    pure fn push_rel(&self, other: &WindowsPath) -> WindowsPath {
         assert !other.is_absolute;
         self.push_many(other.components)
     }
 
-    pure fn unsafe_join(other: &WindowsPath) -> WindowsPath {
+    pure fn unsafe_join(&self, other: &WindowsPath) -> WindowsPath {
         /* rhs not absolute is simple push */
         if !other.is_absolute {
             return self.push_many(other.components);
@@ -743,7 +743,7 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn is_restricted() -> bool {
+    pure fn is_restricted(&self) -> bool {
         match self.filestem() {
             Some(stem) => {
                 match stem.to_lower() {
@@ -756,7 +756,7 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn push_many(cs: &[~str]) -> WindowsPath {
+    pure fn push_many(&self, cs: &[~str]) -> WindowsPath {
         let mut v = copy self.components;
         for cs.each |e| {
             let mut ss = str::split_nonempty(
@@ -773,14 +773,14 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn push(s: &str) -> WindowsPath {
+    pure fn push(&self, s: &str) -> WindowsPath {
         let mut v = copy self.components;
         let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
         unsafe { v.push_all_move(ss); }
-        return WindowsPath { components: v, ..copy self }
+        return WindowsPath { components: v, ..copy *self }
     }
 
-    pure fn pop() -> WindowsPath {
+    pure fn pop(&self) -> WindowsPath {
         let mut cs = copy self.components;
         if cs.len() != 0 {
             unsafe { cs.pop(); }
@@ -793,7 +793,7 @@ impl GenericPath for WindowsPath {
         }
     }
 
-    pure fn normalize() -> WindowsPath {
+    pure fn normalize(&self) -> WindowsPath {
         return WindowsPath {
             host: copy self.host,
             device: match self.device {
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index c16281706d7..72215e4863f 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -158,14 +158,14 @@ pub fn PacketHeader() -> PacketHeader {
 
 pub impl PacketHeader {
     // Returns the old state.
-    unsafe fn mark_blocked(this: *rust_task) -> State {
+    unsafe fn mark_blocked(&self, this: *rust_task) -> State {
         rustrt::rust_task_ref(this);
         let old_task = swap_task(&mut self.blocked_task, this);
         assert old_task.is_null();
         swap_state_acq(&mut self.state, Blocked)
     }
 
-    unsafe fn unblock() {
+    unsafe fn unblock(&self) {
         let old_task = swap_task(&mut self.blocked_task, ptr::null());
         if !old_task.is_null() {
             unsafe {
@@ -182,12 +182,12 @@ pub impl PacketHeader {
     // unsafe because this can do weird things to the space/time
     // continuum. It ends making multiple unique pointers to the same
     // thing. You'll proobably want to forget them when you're done.
-    unsafe fn buf_header() -> ~BufferHeader {
+    unsafe fn buf_header(&self) -> ~BufferHeader {
         assert self.buffer.is_not_null();
         reinterpret_cast(&self.buffer)
     }
 
-    fn set_buffer<T:Owned>(b: ~Buffer<T>) {
+    fn set_buffer<T:Owned>(&self, b: ~Buffer<T>) {
         unsafe {
             self.buffer = reinterpret_cast(&b);
         }
@@ -202,11 +202,11 @@ pub struct Packet<T> {
 
 #[doc(hidden)]
 pub trait HasBuffer {
-    fn set_buffer(b: *libc::c_void);
+    fn set_buffer(&self, b: *libc::c_void);
 }
 
 impl<T:Owned> HasBuffer for Packet<T> {
-    fn set_buffer(b: *libc::c_void) {
+    fn set_buffer(&self, b: *libc::c_void) {
         self.header.buffer = b;
     }
 }
@@ -715,11 +715,11 @@ pub fn select2<A:Owned,Ab:Owned,B:Owned,Bb:Owned>(
 
 #[doc(hidden)]
 pub trait Selectable {
-    pure fn header() -> *PacketHeader;
+    pure fn header(&self) -> *PacketHeader;
 }
 
 impl Selectable for *PacketHeader {
-    pure fn header() -> *PacketHeader { self }
+    pure fn header(&self) -> *PacketHeader { *self }
 }
 
 /// Returns the index of an endpoint that is ready to receive.
@@ -797,13 +797,13 @@ pub fn SendPacketBuffered<T,Tbuffer>(p: *Packet<T>)
 }
 
 pub impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
-    fn unwrap() -> *Packet<T> {
+    fn unwrap(&self) -> *Packet<T> {
         let mut p = None;
         p <-> self.p;
         option::unwrap(p)
     }
 
-    pure fn header() -> *PacketHeader {
+    pure fn header(&self) -> *PacketHeader {
         match self.p {
           Some(packet) => unsafe {
             let packet = &*packet;
@@ -815,7 +815,7 @@ pub impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
         }
     }
 
-    fn reuse_buffer() -> BufferResource<Tbuffer> {
+    fn reuse_buffer(&self) -> BufferResource<Tbuffer> {
         //error!("send reuse_buffer");
         let mut tmp = None;
         tmp <-> self.buffer;
@@ -854,13 +854,13 @@ impl<T:Owned,Tbuffer:Owned> ::ops::Drop for RecvPacketBuffered<T,Tbuffer> {
 }
 
 pub impl<T:Owned,Tbuffer:Owned> RecvPacketBuffered<T, Tbuffer> {
-    fn unwrap() -> *Packet<T> {
+    fn unwrap(&self) -> *Packet<T> {
         let mut p = None;
         p <-> self.p;
         option::unwrap(p)
     }
 
-    fn reuse_buffer() -> BufferResource<Tbuffer> {
+    fn reuse_buffer(&self) -> BufferResource<Tbuffer> {
         //error!("recv reuse_buffer");
         let mut tmp = None;
         tmp <-> self.buffer;
@@ -869,7 +869,7 @@ pub impl<T:Owned,Tbuffer:Owned> RecvPacketBuffered<T, Tbuffer> {
 }
 
 impl<T:Owned,Tbuffer:Owned> Selectable for RecvPacketBuffered<T, Tbuffer> {
-    pure fn header() -> *PacketHeader {
+    pure fn header(&self) -> *PacketHeader {
         match self.p {
           Some(packet) => unsafe {
             let packet = &*packet;
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index bc2d285ad14..c8f5d322523 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -175,39 +175,39 @@ pub pure fn ref_eq<T>(thing: &a/T, other: &b/T) -> bool {
 }
 
 pub trait Ptr<T> {
-    pure fn is_null() -> bool;
-    pure fn is_not_null() -> bool;
-    pure fn offset(count: uint) -> Self;
+    pure fn is_null(&self) -> bool;
+    pure fn is_not_null(&self) -> bool;
+    pure fn offset(&self, count: uint) -> Self;
 }
 
 /// Extension methods for immutable pointers
 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) }
+    pure fn is_null(&self) -> bool { is_null(*self) }
 
     /// Returns true if the pointer is not equal to the null pointer.
     #[inline(always)]
-    pure fn is_not_null() -> bool { is_not_null(self) }
+    pure fn is_not_null(&self) -> bool { is_not_null(*self) }
 
     /// Calculates the offset from a pointer.
     #[inline(always)]
-    pure fn offset(count: uint) -> *T { offset(self, count) }
+    pure fn offset(&self, count: uint) -> *T { offset(*self, count) }
 }
 
 /// Extension methods for mutable pointers
 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) }
+    pure fn is_null(&self) -> bool { is_null(*self) }
 
     /// Returns true if the pointer is not equal to the null pointer.
     #[inline(always)]
-    pure fn is_not_null() -> bool { is_not_null(self) }
+    pure fn is_not_null(&self) -> bool { is_not_null(*self) }
 
     /// Calculates the offset from a mutable pointer.
     #[inline(always)]
-    pure fn offset(count: uint) -> *mut T { mut_offset(self, count) }
+    pure fn offset(&self, count: uint) -> *mut T { mut_offset(*self, count) }
 }
 
 // Equality for pointers
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index d9c2b91fb97..377bf5bf4e7 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -131,7 +131,7 @@ extern mod rustrt {
 /// A random number generator
 pub trait Rng {
     /// Return the next random integer
-    fn next() -> u32;
+    fn next(&self) -> u32;
 }
 
 /// A value with a particular weight compared to other values
@@ -143,12 +143,12 @@ pub struct Weighted<T> {
 /// Extension methods for random number generators
 pub impl Rng {
     /// Return a random value for a Rand type
-    fn gen<T:Rand>() -> T {
-        Rand::rand(self)
+    fn gen<T:Rand>(&self) -> T {
+        Rand::rand(*self)
     }
 
     /// Return a random int
-    fn gen_int() -> int {
+    fn gen_int(&self) -> int {
         self.gen_i64() as int
     }
 
@@ -156,33 +156,33 @@ pub impl Rng {
      * Return an int randomly chosen from the range [start, end),
      * failing if start >= end
      */
-    fn gen_int_range(start: int, end: int) -> int {
+    fn gen_int_range(&self, start: int, end: int) -> int {
         assert start < end;
         start + int::abs(self.gen_int() % (end - start))
     }
 
     /// Return a random i8
-    fn gen_i8() -> i8 {
+    fn gen_i8(&self) -> i8 {
         self.next() as i8
     }
 
     /// Return a random i16
-    fn gen_i16() -> i16 {
+    fn gen_i16(&self) -> i16 {
         self.next() as i16
     }
 
     /// Return a random i32
-    fn gen_i32() -> i32 {
+    fn gen_i32(&self) -> i32 {
         self.next() as i32
     }
 
     /// Return a random i64
-    fn gen_i64() -> i64 {
+    fn gen_i64(&self) -> i64 {
         (self.next() as i64 << 32) | self.next() as i64
     }
 
     /// Return a random uint
-    fn gen_uint() -> uint {
+    fn gen_uint(&self) -> uint {
         self.gen_u64() as uint
     }
 
@@ -190,43 +190,43 @@ pub impl Rng {
      * Return a uint randomly chosen from the range [start, end),
      * failing if start >= end
      */
-    fn gen_uint_range(start: uint, end: uint) -> uint {
+    fn gen_uint_range(&self, start: uint, end: uint) -> uint {
         assert start < end;
         start + (self.gen_uint() % (end - start))
     }
 
     /// Return a random u8
-    fn gen_u8() -> u8 {
+    fn gen_u8(&self) -> u8 {
         self.next() as u8
     }
 
     /// Return a random u16
-    fn gen_u16() -> u16 {
+    fn gen_u16(&self) -> u16 {
         self.next() as u16
     }
 
     /// Return a random u32
-    fn gen_u32() -> u32 {
+    fn gen_u32(&self) -> u32 {
         self.next()
     }
 
     /// Return a random u64
-    fn gen_u64() -> u64 {
+    fn gen_u64(&self) -> u64 {
         (self.next() as u64 << 32) | self.next() as u64
     }
 
     /// Return a random float in the interval [0,1]
-    fn gen_float() -> float {
+    fn gen_float(&self) -> float {
         self.gen_f64() as float
     }
 
     /// Return a random f32 in the interval [0,1]
-    fn gen_f32() -> f32 {
+    fn gen_f32(&self) -> f32 {
         self.gen_f64() as f32
     }
 
     /// Return a random f64 in the interval [0,1]
-    fn gen_f64() -> f64 {
+    fn gen_f64(&self) -> f64 {
         let u1 = self.next() as f64;
         let u2 = self.next() as f64;
         let u3 = self.next() as f64;
@@ -235,25 +235,25 @@ pub impl Rng {
     }
 
     /// Return a random char
-    fn gen_char() -> char {
+    fn gen_char(&self) -> char {
         self.next() as char
     }
 
     /**
      * Return a char randomly chosen from chars, failing if chars is empty
      */
-    fn gen_char_from(chars: &str) -> char {
+    fn gen_char_from(&self, chars: &str) -> char {
         assert !chars.is_empty();
         self.choose(str::chars(chars))
     }
 
     /// Return a random bool
-    fn gen_bool() -> bool {
+    fn gen_bool(&self) -> bool {
         self.next() & 1u32 == 1u32
     }
 
     /// Return a bool with a 1 in n chance of true
-    fn gen_weighted_bool(n: uint) -> bool {
+    fn gen_weighted_bool(&self, n: uint) -> bool {
         if n == 0u {
             true
         } else {
@@ -264,7 +264,7 @@ pub impl Rng {
     /**
      * Return a random string of the specified length composed of A-Z,a-z,0-9
      */
-    fn gen_str(len: uint) -> ~str {
+    fn gen_str(&self, len: uint) -> ~str {
         let charset = ~"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                        abcdefghijklmnopqrstuvwxyz\
                        0123456789";
@@ -278,19 +278,19 @@ pub impl Rng {
     }
 
     /// Return a random byte string of the specified length
-    fn gen_bytes(len: uint) -> ~[u8] {
+    fn gen_bytes(&self, len: uint) -> ~[u8] {
         do vec::from_fn(len) |_i| {
             self.gen_u8()
         }
     }
 
     /// Choose an item randomly, failing if values is empty
-    fn choose<T:Copy>(values: &[T]) -> T {
+    fn choose<T:Copy>(&self, values: &[T]) -> T {
         self.choose_option(values).get()
     }
 
     /// Choose Some(item) randomly, returning None if values is empty
-    fn choose_option<T:Copy>(values: &[T]) -> Option<T> {
+    fn choose_option<T:Copy>(&self, values: &[T]) -> Option<T> {
         if values.is_empty() {
             None
         } else {
@@ -302,7 +302,7 @@ pub impl Rng {
      * Choose an item respecting the relative weights, failing if the sum of
      * the weights is 0
      */
-    fn choose_weighted<T:Copy>(v : &[Weighted<T>]) -> T {
+    fn choose_weighted<T:Copy>(&self, v : &[Weighted<T>]) -> T {
         self.choose_weighted_option(v).get()
     }
 
@@ -310,7 +310,7 @@ pub impl Rng {
      * Choose Some(item) respecting the relative weights, returning none if
      * the sum of the weights is 0
      */
-    fn choose_weighted_option<T:Copy>(v: &[Weighted<T>]) -> Option<T> {
+    fn choose_weighted_option<T:Copy>(&self, v: &[Weighted<T>]) -> Option<T> {
         let mut total = 0u;
         for v.each |item| {
             total += item.weight;
@@ -333,7 +333,7 @@ pub impl Rng {
      * Return a vec containing copies of the items, in order, where
      * the weight of the item determines how many copies there are
      */
-    fn weighted_vec<T:Copy>(v: &[Weighted<T>]) -> ~[T] {
+    fn weighted_vec<T:Copy>(&self, v: &[Weighted<T>]) -> ~[T] {
         let mut r = ~[];
         for v.each |item| {
             for uint::range(0u, item.weight) |_i| {
@@ -344,14 +344,14 @@ pub impl Rng {
     }
 
     /// Shuffle a vec
-    fn shuffle<T:Copy>(values: &[T]) -> ~[T] {
+    fn shuffle<T:Copy>(&self, values: &[T]) -> ~[T] {
         let mut m = vec::from_slice(values);
         self.shuffle_mut(m);
         m
     }
 
     /// Shuffle a mutable vec in place
-    fn shuffle_mut<T>(values: &mut [T]) {
+    fn shuffle_mut<T>(&self, values: &mut [T]) {
         let mut i = values.len();
         while i >= 2u {
             // invariant: elements with index >= i have been locked in place.
@@ -382,7 +382,7 @@ fn RandRes(rng: *rust_rng) -> RandRes {
 }
 
 impl Rng for @RandRes {
-    fn next() -> u32 {
+    fn next(&self) -> u32 {
         unsafe {
             return rustrt::rand_next((*self).rng);
         }
@@ -432,7 +432,7 @@ struct XorShiftState {
 }
 
 impl Rng for XorShiftState {
-    fn next() -> u32 {
+    fn next(&self) -> u32 {
         let x = self.x;
         let mut t = x ^ (x << 11);
         self.x = self.y;
diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs
index 06ae4eb17a5..f29447ef53e 100644
--- a/src/libcore/reflect.rs
+++ b/src/libcore/reflect.rs
@@ -26,9 +26,9 @@ use vec;
  * then build a MovePtrAdaptor wrapped around your struct.
  */
 pub trait MovePtr {
-    fn move_ptr(adjustment: fn(*c_void) -> *c_void);
-    fn push_ptr();
-    fn pop_ptr();
+    fn move_ptr(&self, adjustment: fn(*c_void) -> *c_void);
+    fn push_ptr(&self);
+    fn pop_ptr(&self);
 }
 
 /// Helper function for alignment calculation.
@@ -47,26 +47,26 @@ pub fn MovePtrAdaptor<V:TyVisitor + MovePtr>(v: V) -> MovePtrAdaptor<V> {
 
 pub impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> {
     #[inline(always)]
-    fn bump(sz: uint) {
+    fn bump(&self, sz: uint) {
       do self.inner.move_ptr() |p| {
             ((p as uint) + sz) as *c_void
       };
     }
 
     #[inline(always)]
-    fn align(a: uint) {
+    fn align(&self, a: uint) {
       do self.inner.move_ptr() |p| {
             align(p as uint, a) as *c_void
       };
     }
 
     #[inline(always)]
-    fn align_to<T>() {
+    fn align_to<T>(&self) {
         self.align(sys::min_align_of::<T>());
     }
 
     #[inline(always)]
-    fn bump_past<T>() {
+    fn bump_past<T>(&self) {
         self.bump(sys::size_of::<T>());
     }
 }
diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs
index d0910e7cefb..e68ba26c4c1 100644
--- a/src/libcore/repr.rs
+++ b/src/libcore/repr.rs
@@ -39,11 +39,11 @@ pub use managed::raw::BoxRepr;
 /// Helpers
 
 trait EscapedCharWriter {
-    fn write_escaped_char(ch: char);
+    fn write_escaped_char(&self, ch: char);
 }
 
 impl EscapedCharWriter for Writer {
-    fn write_escaped_char(ch: char) {
+    fn write_escaped_char(&self, ch: char) {
         match ch {
             '\t' => self.write_str("\\t"),
             '\r' => self.write_str("\\r"),
@@ -64,68 +64,76 @@ impl EscapedCharWriter for Writer {
 /// Representations
 
 trait Repr {
-    fn write_repr(writer: @Writer);
+    fn write_repr(&self, writer: @Writer);
 }
 
 impl Repr for () {
-    fn write_repr(writer: @Writer) { writer.write_str("()"); }
+    fn write_repr(&self, writer: @Writer) { writer.write_str("()"); }
 }
 
 impl Repr for bool {
-    fn write_repr(writer: @Writer) {
-        writer.write_str(if self { "true" } else { "false" })
+    fn write_repr(&self, writer: @Writer) {
+        writer.write_str(if *self { "true" } else { "false" })
     }
 }
 
 impl Repr for int {
-    fn write_repr(writer: @Writer) { writer.write_int(self); }
+    fn write_repr(&self, writer: @Writer) { writer.write_int(*self); }
 }
 impl Repr for i8 {
-    fn write_repr(writer: @Writer) { writer.write_int(self as int); }
+    fn write_repr(&self, writer: @Writer) { writer.write_int(*self as int); }
 }
 impl Repr for i16 {
-    fn write_repr(writer: @Writer) { writer.write_int(self as int); }
+    fn write_repr(&self, writer: @Writer) { writer.write_int(*self as int); }
 }
 impl Repr for i32 {
-    fn write_repr(writer: @Writer) { writer.write_int(self as int); }
+    fn write_repr(&self, writer: @Writer) { writer.write_int(*self as int); }
 }
 impl Repr for i64 {
     // FIXME #4424: This can lose precision.
-    fn write_repr(writer: @Writer) { writer.write_int(self as int); }
+    fn write_repr(&self, writer: @Writer) { writer.write_int(*self as int); }
 }
 
 impl Repr for uint {
-    fn write_repr(writer: @Writer) { writer.write_uint(self); }
+    fn write_repr(&self, writer: @Writer) { writer.write_uint(*self); }
 }
 impl Repr for u8 {
-    fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
+    fn write_repr(&self, writer: @Writer) {
+        writer.write_uint(*self as uint);
+    }
 }
 impl Repr for u16 {
-    fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
+    fn write_repr(&self, writer: @Writer) {
+        writer.write_uint(*self as uint);
+    }
 }
 impl Repr for u32 {
-    fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
+    fn write_repr(&self, writer: @Writer) {
+        writer.write_uint(*self as uint);
+    }
 }
 impl Repr for u64 {
     // FIXME #4424: This can lose precision.
-    fn write_repr(writer: @Writer) { writer.write_uint(self as uint); }
+    fn write_repr(&self, writer: @Writer) {
+        writer.write_uint(*self as uint);
+    }
 }
 
 impl Repr for float {
     // FIXME #4423: This mallocs.
-    fn write_repr(writer: @Writer) { writer.write_str(self.to_str()); }
+    fn write_repr(&self, writer: @Writer) { writer.write_str(self.to_str()); }
 }
 impl Repr for f32 {
     // FIXME #4423 This mallocs.
-    fn write_repr(writer: @Writer) { writer.write_str(self.to_str()); }
+    fn write_repr(&self, writer: @Writer) { writer.write_str(self.to_str()); }
 }
 impl Repr for f64 {
     // FIXME #4423: This mallocs.
-    fn write_repr(writer: @Writer) { writer.write_str(self.to_str()); }
+    fn write_repr(&self, writer: @Writer) { writer.write_str(self.to_str()); }
 }
 
 impl Repr for char {
-    fn write_repr(writer: @Writer) { writer.write_char(self); }
+    fn write_repr(&self, writer: @Writer) { writer.write_char(*self); }
 }
 
 
@@ -152,13 +160,13 @@ pub fn ReprVisitor(ptr: *c_void, writer: @Writer) -> ReprVisitor {
 
 impl MovePtr for ReprVisitor {
     #[inline(always)]
-    fn move_ptr(adjustment: fn(*c_void) -> *c_void) {
+    fn move_ptr(&self, adjustment: fn(*c_void) -> *c_void) {
         self.ptr = adjustment(self.ptr);
     }
-    fn push_ptr() {
+    fn push_ptr(&self) {
         self.ptr_stk.push(self.ptr);
     }
-    fn pop_ptr() {
+    fn pop_ptr(&self) {
         self.ptr = self.ptr_stk.pop();
     }
 }
@@ -168,7 +176,7 @@ pub impl ReprVisitor {
     // Various helpers for the TyVisitor impl
 
     #[inline(always)]
-    fn get<T>(f: fn(&T)) -> bool {
+    fn get<T>(&self, f: fn(&T)) -> bool {
         unsafe {
             f(transmute::<*c_void,&T>(copy self.ptr));
         }
@@ -176,24 +184,24 @@ pub impl ReprVisitor {
     }
 
     #[inline(always)]
-    fn bump(sz: uint) {
+    fn bump(&self, sz: uint) {
       do self.move_ptr() |p| {
             ((p as uint) + sz) as *c_void
       };
     }
 
     #[inline(always)]
-    fn bump_past<T>() {
+    fn bump_past<T>(&self) {
         self.bump(sys::size_of::<T>());
     }
 
     #[inline(always)]
-    fn visit_inner(inner: *TyDesc) -> bool {
+    fn visit_inner(&self, inner: *TyDesc) -> bool {
         self.visit_ptr_inner(self.ptr, inner)
     }
 
     #[inline(always)]
-    fn visit_ptr_inner(ptr: *c_void, inner: *TyDesc) -> bool {
+    fn visit_ptr_inner(&self, ptr: *c_void, inner: *TyDesc) -> bool {
         unsafe {
             let mut u = ReprVisitor(ptr, self.writer);
             let v = reflect::MovePtrAdaptor(u);
@@ -203,13 +211,13 @@ pub impl ReprVisitor {
     }
 
     #[inline(always)]
-    fn write<T:Repr>() -> bool {
+    fn write<T:Repr>(&self) -> bool {
         do self.get |v:&T| {
             v.write_repr(self.writer);
         }
     }
 
-    fn write_escaped_slice(slice: &str) {
+    fn write_escaped_slice(&self, slice: &str) {
         self.writer.write_char('"');
         for str::chars_each(slice) |ch| {
             self.writer.write_escaped_char(ch);
@@ -217,7 +225,7 @@ pub impl ReprVisitor {
         self.writer.write_char('"');
     }
 
-    fn write_mut_qualifier(mtbl: uint) {
+    fn write_mut_qualifier(&self, mtbl: uint) {
         if mtbl == 0 {
             self.writer.write_str("mut ");
         } else if mtbl == 1 {
@@ -228,7 +236,7 @@ pub impl ReprVisitor {
         }
     }
 
-    fn write_vec_range(mtbl: uint, ptr: *u8, len: uint,
+    fn write_vec_range(&self, mtbl: uint, ptr: *u8, len: uint,
                        inner: *TyDesc) -> bool {
         let mut p = ptr;
         let end = ptr::offset(p, len);
@@ -249,7 +257,7 @@ pub impl ReprVisitor {
         true
     }
 
-    fn write_unboxed_vec_repr(mtbl: uint, v: &UnboxedVecRepr,
+    fn write_unboxed_vec_repr(&self, mtbl: uint, v: &UnboxedVecRepr,
                               inner: *TyDesc) -> bool {
         self.write_vec_range(mtbl, ptr::to_unsafe_ptr(&v.data),
                              v.fill, inner)
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 471e1ae5396..892956e285e 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -2197,22 +2197,22 @@ pub mod raw {
 }
 
 pub trait Trimmable {
-    pure fn trim() -> Self;
-    pure fn trim_left() -> Self;
-    pure fn trim_right() -> Self;
+    pure fn trim(&self) -> Self;
+    pure fn trim_left(&self) -> Self;
+    pure fn trim_right(&self) -> Self;
 }
 
 /// Extension methods for strings
 impl Trimmable for ~str {
     /// Returns a string with leading and trailing whitespace removed
     #[inline]
-    pure fn trim() -> ~str { trim(self) }
+    pure fn trim(&self) -> ~str { trim(*self) }
     /// Returns a string with leading whitespace removed
     #[inline]
-    pure fn trim_left() -> ~str { trim_left(self) }
+    pure fn trim_left(&self) -> ~str { trim_left(*self) }
     /// Returns a string with trailing whitespace removed
     #[inline]
-    pure fn trim_right() -> ~str { trim_right(self) }
+    pure fn trim_right(&self) -> ~str { trim_right(*self) }
 }
 
 #[cfg(notest)]
@@ -2232,35 +2232,35 @@ pub mod traits {
 pub mod traits {}
 
 pub trait StrSlice {
-    pure fn all(it: fn(char) -> bool) -> bool;
-    pure fn any(it: fn(char) -> bool) -> bool;
-    pure fn contains(needle: &a/str) -> bool;
-    pure fn contains_char(needle: char) -> bool;
-    pure fn each(it: fn(u8) -> bool);
-    pure fn eachi(it: fn(uint, u8) -> bool);
-    pure fn each_char(it: fn(char) -> bool);
-    pure fn each_chari(it: fn(uint, char) -> bool);
-    pure fn ends_with(needle: &str) -> bool;
-    pure fn is_empty() -> bool;
-    pure fn is_whitespace() -> bool;
-    pure fn is_alphanumeric() -> bool;
-    pure fn len() -> uint;
-    pure fn slice(begin: uint, end: uint) -> ~str;
-    pure fn split(sepfn: fn(char) -> bool) -> ~[~str];
-    pure fn split_char(sep: char) -> ~[~str];
-    pure fn split_str(sep: &a/str) -> ~[~str];
-    pure fn starts_with(needle: &a/str) -> bool;
-    pure fn substr(begin: uint, n: uint) -> ~str;
-    pure fn to_lower() -> ~str;
-    pure fn to_upper() -> ~str;
-    pure fn escape_default() -> ~str;
-    pure fn escape_unicode() -> ~str;
-    pure fn trim() -> ~str;
-    pure fn trim_left() -> ~str;
-    pure fn trim_right() -> ~str;
-    pure fn to_owned() -> ~str;
-    pure fn to_managed() -> @str;
-    pure fn char_at(i: uint) -> char;
+    pure fn all(&self, it: fn(char) -> bool) -> bool;
+    pure fn any(&self, it: fn(char) -> bool) -> bool;
+    pure fn contains(&self, needle: &a/str) -> bool;
+    pure fn contains_char(&self, needle: char) -> bool;
+    pure fn each(&self, it: fn(u8) -> bool);
+    pure fn eachi(&self, it: fn(uint, u8) -> bool);
+    pure fn each_char(&self, it: fn(char) -> bool);
+    pure fn each_chari(&self, it: fn(uint, char) -> bool);
+    pure fn ends_with(&self, needle: &str) -> bool;
+    pure fn is_empty(&self) -> bool;
+    pure fn is_whitespace(&self) -> bool;
+    pure fn is_alphanumeric(&self) -> bool;
+    pure fn len(&self) -> uint;
+    pure fn slice(&self, begin: uint, end: uint) -> ~str;
+    pure fn split(&self, sepfn: fn(char) -> bool) -> ~[~str];
+    pure fn split_char(&self, sep: char) -> ~[~str];
+    pure fn split_str(&self, sep: &a/str) -> ~[~str];
+    pure fn starts_with(&self, needle: &a/str) -> bool;
+    pure fn substr(&self, begin: uint, n: uint) -> ~str;
+    pure fn to_lower(&self) -> ~str;
+    pure fn to_upper(&self) -> ~str;
+    pure fn escape_default(&self) -> ~str;
+    pure fn escape_unicode(&self) -> ~str;
+    pure fn trim(&self) -> ~str;
+    pure fn trim_left(&self) -> ~str;
+    pure fn trim_right(&self) -> ~str;
+    pure fn to_owned(&self) -> ~str;
+    pure fn to_managed(&self) -> @str;
+    pure fn char_at(&self, i: uint) -> char;
 }
 
 /// Extension methods for strings
@@ -2270,56 +2270,62 @@ impl StrSlice for &str {
      * contains no characters
      */
     #[inline]
-    pure fn all(it: fn(char) -> bool) -> bool { all(self, it) }
+    pure fn all(&self, it: fn(char) -> bool) -> bool { all(*self, it) }
     /**
      * Return true if a predicate matches any character (and false if it
      * matches none or there are no characters)
      */
     #[inline]
-    pure fn any(it: fn(char) -> bool) -> bool { any(self, it) }
+    pure fn any(&self, it: fn(char) -> bool) -> bool { any(*self, it) }
     /// Returns true if one string contains another
     #[inline]
-    pure fn contains(needle: &a/str) -> bool { contains(self, needle) }
+    pure fn contains(&self, needle: &a/str) -> bool {
+        contains(*self, needle)
+    }
     /// Returns true if a string contains a char
     #[inline]
-    pure fn contains_char(needle: char) -> bool {
-        contains_char(self, needle)
+    pure fn contains_char(&self, needle: char) -> bool {
+        contains_char(*self, needle)
     }
     /// Iterate over the bytes in a string
     #[inline]
-    pure fn each(it: fn(u8) -> bool) { each(self, it) }
+    pure fn each(&self, it: fn(u8) -> bool) { each(*self, it) }
     /// Iterate over the bytes in a string, with indices
     #[inline]
-    pure fn eachi(it: fn(uint, u8) -> bool) { eachi(self, it) }
+    pure fn eachi(&self, it: fn(uint, u8) -> bool) { eachi(*self, it) }
     /// Iterate over the chars in a string
     #[inline]
-    pure fn each_char(it: fn(char) -> bool) { each_char(self, it) }
+    pure fn each_char(&self, it: fn(char) -> bool) { each_char(*self, it) }
     /// Iterate over the chars in a string, with indices
     #[inline]
-    pure fn each_chari(it: fn(uint, char) -> bool) { each_chari(self, it) }
+    pure fn each_chari(&self, it: fn(uint, char) -> bool) {
+        each_chari(*self, it)
+    }
     /// Returns true if one string ends with another
     #[inline]
-    pure fn ends_with(needle: &str) -> bool { ends_with(self, needle) }
+    pure fn ends_with(&self, needle: &str) -> bool {
+        ends_with(*self, needle)
+    }
     /// Returns true if the string has length 0
     #[inline]
-    pure fn is_empty() -> bool { is_empty(self) }
+    pure fn is_empty(&self) -> bool { is_empty(*self) }
     /**
      * Returns true if the string contains only whitespace
      *
      * Whitespace characters are determined by `char::is_whitespace`
      */
     #[inline]
-    pure fn is_whitespace() -> bool { is_whitespace(self) }
+    pure fn is_whitespace(&self) -> bool { is_whitespace(*self) }
     /**
      * Returns true if the string contains only alphanumerics
      *
      * Alphanumeric characters are determined by `char::is_alphanumeric`
      */
     #[inline]
-    pure fn is_alphanumeric() -> bool { is_alphanumeric(self) }
+    pure fn is_alphanumeric(&self) -> bool { is_alphanumeric(*self) }
     #[inline]
     /// Returns the size in bytes not counting the null terminator
-    pure fn len() -> uint { len(self) }
+    pure fn len(&self) -> uint { len(*self) }
     /**
      * Returns a slice of the given string from the byte range
      * [`begin`..`end`)
@@ -2328,24 +2334,30 @@ impl StrSlice for &str {
      * beyond the last character of the string
      */
     #[inline]
-    pure fn slice(begin: uint, end: uint) -> ~str { slice(self, begin, end) }
+    pure fn slice(&self, begin: uint, end: uint) -> ~str {
+        slice(*self, begin, end)
+    }
     /// Splits a string into substrings using a character function
     #[inline]
-    pure fn split(sepfn: fn(char) -> bool) -> ~[~str] { split(self, sepfn) }
+    pure fn split(&self, sepfn: fn(char) -> bool) -> ~[~str] {
+        split(*self, sepfn)
+    }
     /**
      * Splits a string into substrings at each occurrence of a given character
      */
     #[inline]
-    pure fn split_char(sep: char) -> ~[~str] { split_char(self, sep) }
+    pure fn split_char(&self, sep: char) -> ~[~str] { split_char(*self, sep) }
     /**
      * Splits a string into a vector of the substrings separated by a given
      * string
      */
     #[inline]
-    pure fn split_str(sep: &a/str) -> ~[~str] { split_str(self, sep) }
+    pure fn split_str(&self, sep: &a/str) -> ~[~str] { split_str(*self, sep) }
     /// Returns true if one string starts with another
     #[inline]
-    pure fn starts_with(needle: &a/str) -> bool { starts_with(self, needle) }
+    pure fn starts_with(&self, needle: &a/str) -> bool {
+        starts_with(*self, needle)
+    }
     /**
      * Take a substring of another.
      *
@@ -2353,35 +2365,37 @@ impl StrSlice for &str {
      * `begin`.
      */
     #[inline]
-    pure fn substr(begin: uint, n: uint) -> ~str { substr(self, begin, n) }
+    pure fn substr(&self, begin: uint, n: uint) -> ~str {
+        substr(*self, begin, n)
+    }
     /// Convert a string to lowercase
     #[inline]
-    pure fn to_lower() -> ~str { to_lower(self) }
+    pure fn to_lower(&self) -> ~str { to_lower(*self) }
     /// Convert a string to uppercase
     #[inline]
-    pure fn to_upper() -> ~str { to_upper(self) }
+    pure fn to_upper(&self) -> ~str { to_upper(*self) }
     /// Escape each char in `s` with char::escape_default.
     #[inline]
-    pure fn escape_default() -> ~str { escape_default(self) }
+    pure fn escape_default(&self) -> ~str { escape_default(*self) }
     /// Escape each char in `s` with char::escape_unicode.
     #[inline]
-    pure fn escape_unicode() -> ~str { escape_unicode(self) }
+    pure fn escape_unicode(&self) -> ~str { escape_unicode(*self) }
 
     /// Returns a string with leading and trailing whitespace removed
     #[inline]
-    pure fn trim() -> ~str { trim(self) }
+    pure fn trim(&self) -> ~str { trim(*self) }
     /// Returns a string with leading whitespace removed
     #[inline]
-    pure fn trim_left() -> ~str { trim_left(self) }
+    pure fn trim_left(&self) -> ~str { trim_left(*self) }
     /// Returns a string with trailing whitespace removed
     #[inline]
-    pure fn trim_right() -> ~str { trim_right(self) }
+    pure fn trim_right(&self) -> ~str { trim_right(*self) }
 
     #[inline]
-    pure fn to_owned() -> ~str { self.slice(0, self.len()) }
+    pure fn to_owned(&self) -> ~str { self.slice(0, self.len()) }
 
     #[inline]
-    pure fn to_managed() -> @str {
+    pure fn to_managed(&self) -> @str {
         let v = at_vec::from_fn(self.len() + 1, |i| {
             if i == self.len() { 0 } else { self[i] }
         });
@@ -2389,7 +2403,7 @@ impl StrSlice for &str {
     }
 
     #[inline]
-    pure fn char_at(i: uint) -> char { char_at(self, i) }
+    pure fn char_at(&self, i: uint) -> char { char_at(*self, i) }
 }
 
 pub trait OwnedStr {
diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs
index ff3c8386f0b..e3bc799dfab 100644
--- a/src/libcore/task/mod.rs
+++ b/src/libcore/task/mod.rs
@@ -204,7 +204,7 @@ pub fn task() -> TaskBuilder {
 
 #[doc(hidden)] // FIXME #3538
 priv impl TaskBuilder {
-    fn consume() -> TaskBuilder {
+    fn consume(&self) -> TaskBuilder {
         if self.consumed {
             fail!(~"Cannot copy a task_builder"); // Fake move mode on self
         }
@@ -229,7 +229,7 @@ pub impl TaskBuilder {
      * Decouple the child task's failure from the parent's. If either fails,
      * the other will not be killed.
      */
-    fn unlinked() -> TaskBuilder {
+    fn unlinked(&self) -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
             opts: TaskOpts {
@@ -247,7 +247,7 @@ pub impl TaskBuilder {
      * child's failure will not kill the parent, but the parent's will kill
      * the child.
      */
-    fn supervised() -> TaskBuilder {
+    fn supervised(&self) -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
             opts: TaskOpts {
@@ -264,7 +264,7 @@ pub impl TaskBuilder {
      * Link the child task's and parent task's failures. If either fails, the
      * other will be killed.
      */
-    fn linked() -> TaskBuilder {
+    fn linked(&self) -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
             opts: TaskOpts {
@@ -295,7 +295,7 @@ pub impl TaskBuilder {
      * # Failure
      * Fails if a future_result was already set for this task.
      */
-    fn future_result(blk: fn(v: Port<TaskResult>)) -> TaskBuilder {
+    fn future_result(&self, blk: fn(v: Port<TaskResult>)) -> TaskBuilder {
         // FIXME (#3725): Once linked failure and notification are
         // handled in the library, I can imagine implementing this by just
         // registering an arbitrary number of task::on_exit handlers and
@@ -323,7 +323,7 @@ pub impl TaskBuilder {
         }
     }
     /// Configure a custom scheduler mode for the task.
-    fn sched_mode(mode: SchedMode) -> TaskBuilder {
+    fn sched_mode(&self, mode: SchedMode) -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
             opts: TaskOpts {
@@ -349,7 +349,7 @@ pub impl TaskBuilder {
      * generator by applying the task body which results from the
      * existing body generator to the new body generator.
      */
-    fn add_wrapper(wrapper: @fn(v: ~fn()) -> ~fn()) -> TaskBuilder {
+    fn add_wrapper(&self, wrapper: @fn(v: ~fn()) -> ~fn()) -> TaskBuilder {
         let prev_gen_body = self.gen_body;
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         TaskBuilder {
@@ -377,7 +377,7 @@ pub impl TaskBuilder {
      * When spawning into a new scheduler, the number of threads requested
      * must be greater than zero.
      */
-    fn spawn(f: ~fn()) {
+    fn spawn(&self, f: ~fn()) {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
         let x = self.consume();
         let opts = TaskOpts {
@@ -389,7 +389,7 @@ pub impl TaskBuilder {
         spawn::spawn_raw(opts, (x.gen_body)(f));
     }
     /// Runs a task, while transfering ownership of one argument to the child.
-    fn spawn_with<A:Owned>(arg: A, f: ~fn(v: A)) {
+    fn spawn_with<A:Owned>(&self, arg: A, f: ~fn(v: A)) {
         let arg = Cell(arg);
         do self.spawn {
             f(arg.take());
@@ -409,7 +409,7 @@ pub impl TaskBuilder {
      * # Failure
      * Fails if a future_result was already set for this task.
      */
-    fn try<T:Owned>(f: ~fn() -> T) -> Result<T,()> {
+    fn try<T:Owned>(&self, f: ~fn() -> T) -> Result<T,()> {
         let (po, ch) = stream::<T>();
         let mut result = None;
 
diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs
index ae53081c2db..15fe2a52461 100644
--- a/src/libcore/tuple.rs
+++ b/src/libcore/tuple.rs
@@ -16,31 +16,31 @@ use vec;
 #[cfg(notest)] use cmp::{Eq, Ord};
 
 pub trait CopyableTuple<T, U> {
-    pure fn first() -> T;
-    pure fn second() -> U;
-    pure fn swap() -> (U, T);
+    pure fn first(&self) -> T;
+    pure fn second(&self) -> U;
+    pure fn swap(&self) -> (U, T);
 }
 
 impl<T:Copy,U:Copy> CopyableTuple<T, U> for (T, U) {
 
     /// Return the first element of self
     #[inline(always)]
-    pure fn first() -> T {
-        let (t, _) = self;
+    pure fn first(&self) -> T {
+        let (t, _) = *self;
         return t;
     }
 
     /// Return the second element of self
     #[inline(always)]
-    pure fn second() -> U {
-        let (_, u) = self;
+    pure fn second(&self) -> U {
+        let (_, u) = *self;
         return u;
     }
 
     /// Return the results of swapping the two elements of self
     #[inline(always)]
-    pure fn swap() -> (U, T) {
-        let (t, u) = self;
+    pure fn swap(&self) -> (U, T) {
+        let (t, u) = *self;
         return (u, t);
     }
 
diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs
index 9b2a205b673..08328c5af8a 100644
--- a/src/libcore/unstable/extfmt.rs
+++ b/src/libcore/unstable/extfmt.rs
@@ -140,7 +140,7 @@ pub mod ct {
     }
 
     pub impl<T> Parsed<T> {
-        static pure fn new(val: T, next: uint) -> Parsed<T> {
+        static pure fn new(&self, val: T, next: uint) -> Parsed<T> {
             Parsed {val: val, next: next}
         }
     }
diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 02875739eba..14a37ecbf52 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -26,35 +26,35 @@ pub struct DuplexStream<T, U> {
 }
 
 impl<T:Owned,U:Owned> GenericChan<T> for DuplexStream<T, U> {
-    fn send(x: T) {
+    fn send(&self, x: T) {
         self.chan.send(x)
     }
 }
 
 impl<T:Owned,U:Owned> GenericSmartChan<T> for DuplexStream<T, U> {
-    fn try_send(x: T) -> bool {
+    fn try_send(&self, x: T) -> bool {
         self.chan.try_send(x)
     }
 }
 
 impl<T:Owned,U:Owned> GenericPort<U> for DuplexStream<T, U> {
-    fn recv() -> U {
+    fn recv(&self) -> U {
         self.port.recv()
     }
 
-    fn try_recv() -> Option<U> {
+    fn try_recv(&self) -> Option<U> {
         self.port.try_recv()
     }
 }
 
 impl<T:Owned,U:Owned> Peekable<U> for DuplexStream<T, U> {
-    pure fn peek() -> bool {
+    pure fn peek(&self) -> bool {
         self.port.peek()
     }
 }
 
 impl<T:Owned,U:Owned> Selectable for DuplexStream<T, U> {
-    pure fn header() -> *pipes::PacketHeader {
+    pure fn header(&self) -> *pipes::PacketHeader {
         self.port.header()
     }
 }
diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
index 564d34f73d7..8f6ec2b9cd9 100644
--- a/src/libstd/flatpipes.rs
+++ b/src/libstd/flatpipes.rs
@@ -257,13 +257,13 @@ pub trait ByteChan {
 const CONTINUE: [u8 * 4] = [0xAA, 0xBB, 0xCC, 0xDD];
 
 impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
-    fn recv() -> T {
+    fn recv(&self) -> T {
         match self.try_recv() {
             Some(val) => val,
             None => fail!(~"port is closed")
         }
     }
-    fn try_recv() -> Option<T> {
+    fn try_recv(&self) -> Option<T> {
         let command = match self.byte_port.try_recv(CONTINUE.len()) {
             Some(c) => c,
             None => {
@@ -302,7 +302,7 @@ impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
 }
 
 impl<T,F:Flattener<T>,C:ByteChan> GenericChan<T> for FlatChan<T, F, C> {
-    fn send(val: T) {
+    fn send(&self, val: T) {
         self.byte_chan.send(CONTINUE.to_vec());
         let bytes = self.flattener.flatten(val);
         let len = bytes.len() as u64;