librustc: Remove implicit self from the language, except for old-style drop blocks.

doc/tutorial.md

@@ -1135,7 +1135,7 @@ can sometimes make code awkward and parenthesis-filled.
 ~~~
 # struct Point { x: float, y: float }
 # enum Shape { Rectangle(Point, Point) }
-# impl Shape { fn area() -> int { 0 } }
+# impl Shape { fn area(&self) -> int { 0 } }
 let start = @Point { x: 10f, y: 20f };
 let end = ~Point { x: (*start).x + 100f, y: (*start).y + 100f };
 let rect = &Rectangle(*start, *end);
@@ -1149,7 +1149,7 @@ dot), so in most cases, explicitly dereferencing the receiver is not necessary.
 ~~~
 # struct Point { x: float, y: float }
 # enum Shape { Rectangle(Point, Point) }
-# impl Shape { fn area() -> int { 0 } }
+# impl Shape { fn area(&self) -> int { 0 } }
 let start = @Point { x: 10f, y: 20f };
 let end = ~Point { x: start.x + 100f, y: start.y + 100f };
 let rect = &Rectangle(*start, *end);

src/librustc/middle/lint.rs

@@ -75,7 +75,6 @@ pub enum lint {
     non_camel_case_types,
     type_limits,
     default_methods,
-    deprecated_self,
     deprecated_mutable_fields,
     deprecated_drop,
     foreign_mode,
@@ -246,13 +245,6 @@ pub fn get_lint_dict() -> LintDict {
             default: deny
          }),
 
-        (@~"deprecated_self",
-         @LintSpec {
-            lint: deprecated_self,
-            desc: "warn about deprecated uses of `self`",
-            default: warn
-         }),
-
         (@~"deprecated_mutable_fields",
          @LintSpec {
             lint: deprecated_mutable_fields,
@@ -497,7 +489,6 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
     check_item_deprecated_modes(cx, i);
     check_item_type_limits(cx, i);
     check_item_default_methods(cx, i);
-    check_item_deprecated_self(cx, i);
     check_item_deprecated_mutable_fields(cx, i);
     check_item_deprecated_drop(cx, i);
 }
@@ -677,46 +668,6 @@ fn check_item_default_methods(cx: ty::ctxt, item: @ast::item) {
     }
 }
 
-fn check_item_deprecated_self(cx: ty::ctxt, item: @ast::item) {
-    fn maybe_warn(cx: ty::ctxt,
-                  item: @ast::item,
-                  self_ty: ast::self_ty) {
-        match self_ty.node {
-            ast::sty_by_ref => {
-                cx.sess.span_lint(
-                    deprecated_self,
-                    item.id,
-                    item.id,
-                    self_ty.span,
-                    ~"this method form is deprecated; use an explicit `self` \
-                      parameter or mark the method as static");
-            }
-            _ => {}
-        }
-    }
-
-    match /*bad*/copy item.node {
-        ast::item_trait(_, _, methods) => {
-            for methods.each |method| {
-                match /*bad*/copy *method {
-                    ast::required(ty_method) => {
-                        maybe_warn(cx, item, ty_method.self_ty);
-                    }
-                    ast::provided(method) => {
-                        maybe_warn(cx, item, method.self_ty);
-                    }
-                }
-            }
-        }
-        ast::item_impl(_, _, _, methods) => {
-            for methods.each |method| {
-                maybe_warn(cx, item, method.self_ty);
-            }
-        }
-        _ => {}
-    }
-}
-
 fn check_item_deprecated_mutable_fields(cx: ty::ctxt, item: @ast::item) {
     match item.node {
         ast::item_struct(struct_def, _) => {

src/libsyntax/parse/obsolete.rs

@@ -56,6 +56,7 @@ pub enum ObsoleteSyntax {
     ObsoleteBareFnType,
     ObsoleteNewtypeEnum,
     ObsoleteMode,
+    ObsoleteImplicitSelf,
 }
 
 impl to_bytes::IterBytes for ObsoleteSyntax {
@@ -181,6 +182,11 @@ pub impl Parser {
                 "obsolete argument mode",
                 "replace `-` or `++` mode with `+`"
             ),
+            ObsoleteImplicitSelf => (
+                "implicit self",
+                "use an explicit `self` declaration or declare the method as \
+                 static"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);

src/libsyntax/parse/parser.rs

@@ -78,7 +78,7 @@ use parse::obsolete::{ObsoleteMutVector, ObsoleteTraitImplVisibility};
 use parse::obsolete::{ObsoleteRecordType, ObsoleteRecordPattern};
 use parse::obsolete::{ObsoleteAssertion, ObsoletePostFnTySigil};
 use parse::obsolete::{ObsoleteBareFnType, ObsoleteNewtypeEnum};
-use parse::obsolete::{ObsoleteMode};
+use parse::obsolete::{ObsoleteMode, ObsoleteImplicitSelf};
 use parse::prec::{as_prec, token_to_binop};
 use parse::token::{can_begin_expr, is_ident, is_ident_or_path};
 use parse::token::{is_plain_ident, INTERPOLATED, special_idents};
@@ -471,6 +471,10 @@ pub impl Parser {
             // XXX: Wrong. Shouldn't allow both static and self_ty
             let self_ty = if is_static { static_sty } else { self_ty };
 
+            if self_ty.node == sty_by_ref {
+                self.obsolete(self_ty.span, ObsoleteImplicitSelf);
+            }
+
             let hi = p.last_span.hi;
             debug!("parse_trait_methods(): trait method signature ends in \
                     `%s`",
@@ -2981,6 +2985,10 @@ pub impl Parser {
         // XXX: interaction between staticness, self_ty is broken now
         let self_ty = if is_static { static_sty} else { self_ty };
 
+        if self_ty.node == sty_by_ref {
+            self.obsolete(self_ty.span, ObsoleteImplicitSelf);
+        }
+
         let (inner_attrs, body) = self.parse_inner_attrs_and_block(true);
         let hi = body.span.hi;
         let attrs = vec::append(attrs, inner_attrs);

src/test/auxiliary/ambig_impl_2_lib.rs

@@ -9,6 +9,6 @@
 // except according to those terms.
 
 trait me {
-    fn me() -> uint;
+    fn me(&self) -> uint;
 }
-impl me for uint { fn me() -> uint { self } }
+impl me for uint { fn me(&self) -> uint { self } }

src/test/auxiliary/cci_class_2.rs

@@ -17,7 +17,7 @@ pub mod kitties {
     }
 
     pub impl cat {
-        fn speak() {}
+        fn speak(&self) {}
     }
 
     pub fn cat(in_x : uint, in_y : int) -> cat {

src/test/auxiliary/cci_impl_lib.rs

@@ -11,12 +11,12 @@
 #[link(name="cci_impl_lib", vers="0.0")];
 
 trait uint_helpers {
-    fn to(v: uint, f: &fn(uint));
+    fn to(self, v: uint, f: &fn(uint));
 }
 
 impl uint_helpers for uint {
     #[inline]
-    fn to(v: uint, f: &fn(uint)) {
+    fn to(self, v: uint, f: &fn(uint)) {
         let mut i = self;
         while i < v {
             f(i);

src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs

@@ -16,11 +16,11 @@ pub mod name_pool {
     pub type name_pool = ();
 
     pub trait add {
-        fn add(s: ~str);
+        fn add(&self, s: ~str);
     }
 
     impl add for name_pool {
-        fn add(s: ~str) {
+        fn add(&self, s: ~str) {
         }
     }
 }
@@ -31,11 +31,11 @@ pub mod rust {
     pub type rt = @();
 
     pub trait cx {
-        fn cx();
+        fn cx(&self);
     }
 
     impl cx for rt {
-        fn cx() {
+        fn cx(&self) {
         }
     }
 }

src/test/auxiliary/issue-2414-a.rs

@@ -14,10 +14,10 @@
 type t1 = uint;
 
 trait foo {
-    fn foo();
+    fn foo(&self);
 }
 
 impl foo for ~str {
-    fn foo() {}
+    fn foo(&self) {}
 }
 

src/test/auxiliary/issue-2526.rs

@@ -56,5 +56,5 @@ fn context_res() -> context_res {
 pub type context = arc_destruct<context_res>;
 
 pub impl context {
-    fn socket() { }
+    fn socket(&self) { }
 }

src/test/auxiliary/issue_2472_b.rs

@@ -12,13 +12,13 @@
 pub struct S(());
 
 pub impl S {
-    fn foo() { }
+    fn foo(&self) { }
 }
 
 pub trait T {
-    fn bar();
+    fn bar(&self);
 }
 
 impl T for S {
-    fn bar() { }
+    fn bar(&self) { }
 }

src/test/auxiliary/issue_3136_a.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait x {
-    fn use_x<T>();
+    fn use_x<T>(&self);
 }
 struct y(());
 impl x for y { 
-    fn use_x<T>() {
+    fn use_x<T>(&self) {
         struct foo { //~ ERROR quux
             i: ()
         }

src/test/auxiliary/trait_inheritance_auto_xc_2_aux.rs

@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub trait Foo { fn f() -> int; }
-pub trait Bar { fn g() -> int; }
-pub trait Baz { fn h() -> int; }
+pub trait Foo { fn f(&self) -> int; }
+pub trait Bar { fn g(&self) -> int; }
+pub trait Baz { fn h(&self) -> int; }
 
 pub struct A { x: int }
 
-impl Foo for A { fn f() -> int { 10 } }
-impl Bar for A { fn g() -> int { 20 } }
-impl Baz for A { fn h() -> int { 30 } }
+impl Foo for A { fn f(&self) -> int { 10 } }
+impl Bar for A { fn g(&self) -> int { 20 } }
+impl Baz for A { fn h(&self) -> int { 30 } }
 
 

src/test/auxiliary/trait_inheritance_auto_xc_aux.rs

@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait Foo { fn f() -> int; }
-trait Bar { fn g() -> int; }
-trait Baz { fn h() -> int; }
+trait Foo { fn f(&self) -> int; }
+trait Bar { fn g(&self) -> int; }
+trait Baz { fn h(&self) -> int; }
 
 trait Quux: Foo + Bar + Baz { }
 

src/test/auxiliary/trait_inheritance_cross_trait_call_xc_aux.rs

@@ -10,7 +10,7 @@
 
 
 pub trait Foo {
-    fn f() -> int;
+    fn f(&self) -> int;
 }
 
 pub struct A {
@@ -18,5 +18,5 @@ pub struct A {
 }
 
 impl Foo for A {
-    fn f() -> int { 10 }
+    fn f(&self) -> int { 10 }
 }

src/test/compile-fail/ambig_impl_unify.rs

@@ -9,15 +9,15 @@
 // except according to those terms.
 
 trait foo {
-    fn foo() -> int;
+    fn foo(&self) -> int;
 }
 
 impl foo for ~[uint] {
-    fn foo() -> int {1} //~ NOTE candidate #1 is `__extensions__::foo`
+    fn foo(&self) -> int {1} //~ NOTE candidate #1 is `__extensions__::foo`
 }
 
 impl foo for ~[int] {
-    fn foo() -> int {2} //~ NOTE candidate #2 is `__extensions__::foo`
+    fn foo(&self) -> int {2} //~ NOTE candidate #2 is `__extensions__::foo`
 }
 
 fn main() {

src/test/compile-fail/assign-to-method.rs

@@ -16,7 +16,7 @@ struct cat {
 
 pub impl cat {
 
-  fn speak() { self.meows += 1u; }
+  fn speak(&self) { self.meows += 1u; }
 }
 
 fn cat(in_x : uint, in_y : int) -> cat {

src/test/compile-fail/auto-ref-borrowck-failure.rs

@@ -15,11 +15,11 @@ struct Foo {
 }
 
 trait Stuff {
-    fn printme();
+    fn printme(self);
 }
 
 impl Stuff for &'self mut Foo {
-    fn printme() {
+    fn printme(self) {
         io::println(fmt!("%d", self.x));
     }
 }

src/test/compile-fail/bad-method-typaram-kind.rs

@@ -13,11 +13,11 @@ fn foo<T>() {
 }
 
 trait bar {
-    fn bar<T:Copy>();
+    fn bar<T:Copy>(&self);
 }
 
 impl bar for uint {
-    fn bar<T:Copy>() {
+    fn bar<T:Copy>(&self) {
     }
 }
 

src/test/compile-fail/borrowck-autoref-3261.rs

@@ -11,7 +11,7 @@
 struct X(Either<(uint,uint),extern fn()>);
 
 pub impl &'self X {
-    fn with(blk: &fn(x: &Either<(uint,uint),extern fn()>)) {
+    fn with(self, blk: &fn(x: &Either<(uint,uint),extern fn()>)) {
         blk(&**self)
     }
 }

src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs

@@ -20,7 +20,7 @@ impl ops::Add<int,int> for Point {
 }
 
 pub impl Point {
-    fn times(z: int) -> int {
+    fn times(&self, z: int) -> int {
         self.x * self.y * z
     }
 }

src/test/compile-fail/borrowck-loan-rcvr.rs

@@ -11,18 +11,18 @@
 struct point { x: int, y: int }
 
 trait methods {
-    fn impurem();
-    fn blockm(f: &fn());
-    pure fn purem();
+    fn impurem(&self);
+    fn blockm(&self, f: &fn());
+    pure fn purem(&self);
 }
 
 impl methods for point {
-    fn impurem() {
+    fn impurem(&self) {
     }
 
-    fn blockm(f: &fn()) { f() }
+    fn blockm(&self, f: &fn()) { f() }
 
-    pure fn purem() {
+    pure fn purem(&self) {
     }
 }
 

src/test/compile-fail/class-cast-to-trait.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait noisy {
-  fn speak();
+  fn speak(&self);
 }
 
 struct cat {
@@ -21,7 +21,7 @@ struct cat {
 
 pub impl cat {
 
-  fn eat() -> bool {
+  fn eat(&self) -> bool {
     if self.how_hungry > 0 {
         error!("OM NOM NOM");
         self.how_hungry -= 2;
@@ -35,12 +35,12 @@ pub impl cat {
 }
 
 impl noisy for cat {
-  fn speak() { self.meow(); }
+  fn speak(&self) { self.meow(); }
 
 }
 
 priv impl cat {
-    fn meow() {
+    fn meow(&self) {
       error!("Meow");
       self.meows += 1;
       if self.meows % 5 == 0 {
@@ -49,7 +49,7 @@ priv impl cat {
     }
 }
 
-fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
+fn cat(&self, in_x : uint, in_y : int, in_name: ~str) -> cat {
     cat {
         meows: in_x,
         how_hungry: in_y,

src/test/compile-fail/class-method-missing.rs

@@ -10,7 +10,7 @@
 
 // error-pattern:missing method `eat`
 trait animal {
-  fn eat();
+  fn eat(&self);
 }
 
 struct cat {

src/test/compile-fail/class-missing-self.rs

@@ -13,8 +13,8 @@ struct cat {
 }
 
 priv impl cat {
-    fn sleep() { loop{} }
-    fn meow() {
+    fn sleep(&self) { loop{} }
+    fn meow(&self) {
       error!("Meow");
       meows += 1u; //~ ERROR unresolved name
       sleep();     //~ ERROR unresolved name

src/test/compile-fail/explicit-call-to-supertrait-dtor.rs

@@ -13,7 +13,7 @@ struct Foo {
 }
 
 trait Bar : Drop {
-    fn blah();
+    fn blah(&self);
 }
 
 impl Drop for Foo {
@@ -23,7 +23,7 @@ impl Drop for Foo {
 }
 
 impl Bar for Foo {
-    fn blah() {
+    fn blah(&self) {
         self.finalize();    //~ ERROR explicit call to destructor
     }
 }

src/test/compile-fail/infinite-instantiation.rs

@@ -12,17 +12,17 @@
 // issue 2258
 
 trait to_opt {
-    fn to_option() -> Option<Self>;
+    fn to_option(&self) -> Option<Self>;
 }
 
 impl to_opt for uint {
-    fn to_option() -> Option<uint> {
+    fn to_option(&self) -> Option<uint> {
         Some(self)
     }
 }
 
 impl<T:Copy> to_opt for Option<T> {
-    fn to_option() -> Option<Option<T>> {
+    fn to_option(&self) -> Option<Option<T>> {
         Some(self)
     }
 }

src/test/compile-fail/issue-2149.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait vec_monad<A> {
-    fn bind<B>(f: &fn(A) -> ~[B]);
+    fn bind<B>(&self, f: &fn(A) -> ~[B]);
 }
 
 impl<A> vec_monad<A> for ~[A] {
-    fn bind<B>(f: &fn(A) -> ~[B]) {
+    fn bind<B>(&self, f: &fn(A) -> ~[B]) {
         let mut r = fail!();
         for self.each |elt| { r += f(*elt); }
         //~^ WARNING unreachable expression

src/test/compile-fail/issue-2330.rs

@@ -11,12 +11,12 @@
 enum chan { }
 
 trait channel<T> {
-    fn send(v: T);
+    fn send(&self, v: T);
 }
 
 // `chan` is not a trait, it's an enum
 impl chan for int { //~ ERROR can only implement trait types
-    fn send(v: int) { fail!() }
+    fn send(&self, v: int) { fail!() }
 }
 
 fn main() {

src/test/compile-fail/issue-2611-5.rs

@@ -12,7 +12,7 @@
 // an impl against a trait
 
 trait A {
-  fn b<C:Copy,D>(x: C) -> C;
+  fn b<C:Copy,D>(&self, x: C) -> C;
 }
 
 struct E {
@@ -21,7 +21,7 @@ struct E {
 
 impl A for E {
   // n.b. The error message is awful -- see #3404
-  fn b<F:Copy,G>(_x: G) -> G { fail!() } //~ ERROR method `b` has an incompatible type
+  fn b<F:Copy,G>(&self, _x: G) -> G { fail!() } //~ ERROR method `b` has an incompatible type
 }
 
 fn main() {}

src/test/compile-fail/issue-3021-c.rs

@@ -13,7 +13,7 @@ extern mod std;
 fn siphash<T>() {
 
     trait t {
-        fn g(x: T) -> T;  //~ ERROR attempt to use a type argument out of scope
+        fn g(&self, x: T) -> T;  //~ ERROR attempt to use a type argument out of scope
         //~^ ERROR attempt to use a type argument out of scope
         //~^^ ERROR use of undeclared type name `T`
         //~^^^ ERROR use of undeclared type name `T`

src/test/compile-fail/issue-3021-d.rs

@@ -11,8 +11,8 @@
 extern mod std;
 
 trait siphash {
-    fn result() -> u64;
-    fn reset();
+    fn result(&self) -> u64;
+    fn reset(&self);
 }
 
 fn siphash(k0 : u64, k1 : u64) -> siphash {
@@ -21,7 +21,7 @@ fn siphash(k0 : u64, k1 : u64) -> siphash {
         v1: u64,
     }
 
-    fn mk_result(st : SipState) -> u64 {
+    fn mk_result(&self, st : SipState) -> u64 {
 
         let v0 = st.v0,
             v1 = st.v1;
@@ -29,13 +29,13 @@ fn siphash(k0 : u64, k1 : u64) -> siphash {
     }
 
    impl siphash for SipState {
-        fn reset() {
+        fn reset(&self) {
             self.v0 = k0 ^ 0x736f6d6570736575;  //~ ERROR attempted dynamic environment-capture
             //~^ ERROR unresolved name: `k0`.
             self.v1 = k1 ^ 0x646f72616e646f6d;   //~ ERROR attempted dynamic environment-capture
             //~^ ERROR unresolved name: `k1`.
         }
-        fn result() -> u64 { return mk_result(self); }
+        fn result(&self) -> u64 { return mk_result(self); }
     }
 }
 

src/test/compile-fail/issue-3021.rs

@@ -11,7 +11,7 @@
 extern mod std;
 
 trait SipHash {
-    fn reset();
+    fn reset(&self);
 }
 
 fn siphash(k0 : u64) -> SipHash {
@@ -20,7 +20,7 @@ fn siphash(k0 : u64) -> SipHash {
     }
 
     impl SipHash for SipState {
-        fn reset() {
+        fn reset(&self) {
            self.v0 = k0 ^ 0x736f6d6570736575; //~ ERROR attempted dynamic environment-capture
            //~^ ERROR unresolved name: `k0`.
         }

src/test/compile-fail/issue-3668.rs

@@ -10,11 +10,11 @@
 
 struct P { child: Option<@mut P> }
 trait PTrait {
-   fn getChildOption() -> Option<@P>;
+   fn getChildOption(&self) -> Option<@P>;
 }
 
 impl PTrait for P {
-   fn getChildOption() -> Option<@P> {
+   fn getChildOption(&self) -> Option<@P> {
        const childVal: @P = self.child.get(); //~ ERROR attempt to use a non-constant value in a constant
        fail!();
    }

src/test/compile-fail/issue-3763.rs

@@ -16,7 +16,7 @@ mod my_mod {
         MyStruct {priv_field: 4}
     }
     pub impl MyStruct {
-        priv fn happyfun() {}
+        priv fn happyfun(&self) {}
     }
 }
 

src/test/compile-fail/kindck-owned-trait-contains.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait repeat<A> { fn get() -> A; }
+trait repeat<A> { fn get(&self) -> A; }
 
 impl<A:Copy> repeat<A> for @A {
-    fn get() -> A { *self }
+    fn get(&self) -> A { *self }
 }
 
 fn repeater<A:Copy>(v: @A) -> @repeat<A> {

src/test/compile-fail/kindck-owned-trait-scoped.rs

@@ -12,11 +12,11 @@
 // be parameterized by a region due to the &self/int constraint.
 
 trait foo {
-    fn foo(i: &'self int) -> int;
+    fn foo(&self, i: &'self int) -> int;
 }
 
 impl<T:Copy> foo<'self> for T {
-    fn foo(i: &'self int) -> int {*i}
+    fn foo(&self, i: &'self int) -> int {*i}
 }
 
 fn to_foo<T:Copy>(t: T) {

src/test/compile-fail/kindck-owned-trait.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait foo { fn foo(); }
+trait foo { fn foo(&self); }
 
 fn to_foo<T:Copy + foo>(t: T) -> @foo {
     @t as @foo //~ ERROR value may contain borrowed pointers; use `&static` bound

src/test/compile-fail/lint-deprecated-self.rs

@@ -1,20 +0,0 @@
-#[forbid(deprecated_self)]
-mod a {
-    trait T {
-        fn f(); //~ ERROR this method form is deprecated
-    }
-
-    struct S {
-        x: int
-    }
-
-    impl T for S {
-        fn f() {    //~ ERROR this method form is deprecated
-        }
-    }
-}
-
-fn main() {
-}
-
-

src/test/compile-fail/map-types.rs

@@ -15,7 +15,7 @@ use core::hashmap::linear::LinearMap;
 
 fn main() {
     let x: @Map<~str, ~str> = @LinearMap::new::<~str, ~str>() as
-        @Map::<~str, ~str>;
+        @(Map::<~str, ~str>);
     let y: @Map<uint, ~str> = @x;
     //~^ ERROR mismatched types: expected `@core::container::Map<uint,~str>`
 }

src/test/compile-fail/mutable-class-fields-2.rs

@@ -16,7 +16,7 @@ struct cat {
 }
 
 pub impl cat {
-  fn eat() {
+  fn eat(&self) {
     self.how_hungry -= 5;
   }
 

src/test/compile-fail/private-impl-method.rs

@@ -14,7 +14,7 @@ mod a {
     }
 
     pub impl Foo {
-        priv fn foo() {}
+        priv fn foo(&self) {}
     }
 }
 

src/test/compile-fail/private-method.rs

@@ -18,7 +18,7 @@ mod kitties {
     }
 
     pub impl cat {
-        priv fn nap() { uint::range(1u, 10000u, |_i| false)}
+        priv fn nap(&self) { uint::range(1u, 10000u, |_i| false)}
     }
 
     pub fn cat(in_x : uint, in_y : int) -> cat {

src/test/compile-fail/pure-modifies-aliased.rs

@@ -19,11 +19,11 @@ pure fn modify_in_box(sum: @mut S) {
 }
 
 trait modify_in_box_rec {
-    pure fn modify_in_box_rec(sum: @mut S);
+    pure fn modify_in_box_rec(&self, sum: @mut S);
 }
 
 impl modify_in_box_rec for int {
-    pure fn modify_in_box_rec(sum: @mut S) {
+    pure fn modify_in_box_rec(&self, sum: @mut S) {
         sum.f = self; //~ ERROR assigning to mutable field prohibited in pure context
     }
 }

src/test/compile-fail/regions-bounds.rs

@@ -14,7 +14,7 @@
 
 struct an_enum(&'self int);
 trait a_trait {
-    fn foo() -> &'self int;
+    fn foo(&self) -> &'self int;
 }
 struct a_class { x:&'self int }
 

src/test/compile-fail/regions-escape-via-trait-or-not.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait deref {
-    fn get() -> int;
+    fn get(self) -> int;
 }
 
 impl deref for &'self int {
-    fn get() -> int {
+    fn get(self) -> int {
         *self
     }
 }

src/test/compile-fail/regions-infer-paramd-indirect.rs

@@ -19,12 +19,12 @@ struct c<'self> {
 }
 
 trait set_f<'self> {
-    fn set_f_ok(b: @b<'self>);
-    fn set_f_bad(b: @b);
+    fn set_f_ok(&self, b: @b<'self>);
+    fn set_f_bad(&self, b: @b);
 }
 
 impl<'self> set_f<'self> for c<'self> {
-    fn set_f_ok(b: @b<'self>) {
+    fn set_f_ok(&self, b: @b<'self>) {
         self.f = b;
     }
 

src/test/compile-fail/regions-infer-paramd-method.rs

@@ -12,9 +12,9 @@
 // refers to self.
 
 trait foo<'self> {
-    fn self_int() -> &'self int;
+    fn self_int(&self) -> &'self int;
 
-    fn any_int() -> &int;
+    fn any_int(&self) -> &int;
 }
 
 struct with_foo<'self> {
@@ -34,7 +34,7 @@ impl<'self> set_foo_foo for with_foo<'self> {
 // Bar is not region parameterized.
 
 trait bar {
-    fn any_int() -> &int;
+    fn any_int(&self) -> &int;
 }
 
 struct with_bar {

src/test/compile-fail/regions-trait-1.rs

@@ -12,7 +12,7 @@ struct ctxt { v: uint }
 
 trait get_ctxt {
     // Here the `&` is bound in the method definition:
-    fn get_ctxt() -> &ctxt;
+    fn get_ctxt(&self) -> &ctxt;
 }
 
 struct has_ctxt { c: &'self ctxt }
@@ -21,7 +21,7 @@ impl get_ctxt for has_ctxt<'self> {
 
     // Here an error occurs because we used `&self` but
     // the definition used `&`:
-    fn get_ctxt() -> &'self ctxt { //~ ERROR method `get_ctxt` has an incompatible type
+    fn get_ctxt(&self) -> &'self ctxt { //~ ERROR method `get_ctxt` has an incompatible type
         self.c
     }
 

src/test/compile-fail/regions-trait-2.rs

@@ -11,13 +11,13 @@
 struct ctxt { v: uint }
 
 trait get_ctxt<'self> {
-    fn get_ctxt() -> &'self ctxt;
+    fn get_ctxt(&self) -> &'self ctxt;
 }
 
 struct has_ctxt<'self> { c: &'self ctxt }
 
 impl<'self> get_ctxt<'self> for has_ctxt<'self> {
-    fn get_ctxt() -> &self/ctxt { self.c }
+    fn get_ctxt(&self) -> &self/ctxt { self.c }
 }
 
 fn make_gc() -> @get_ctxt  {

src/test/compile-fail/regions-trait-3.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait get_ctxt {
-    fn get_ctxt() -> &self/uint;
+    fn get_ctxt(&self) -> &self/uint;
 }
 
 fn make_gc1(gc: @get_ctxt/&a) -> @get_ctxt/&b  {
@@ -21,7 +21,7 @@ struct Foo {
 }
 
 impl get_ctxt/&self for Foo/&self {
-    fn get_ctxt() -> &self/uint { self.r }
+    fn get_ctxt(&self) -> &self/uint { self.r }
 }
 
 fn make_gc2(foo: Foo/&a) -> @get_ctxt/&b  {

src/test/compile-fail/selftype-traittype.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait add {
-    fn plus(x: Self) -> Self;
+    fn plus(&self, x: Self) -> Self;
 }
 
 fn do_add(x: add, y: add) -> add {

src/test/compile-fail/staticness-mismatch.rs

@@ -14,7 +14,7 @@ trait foo {
 }
 
 impl foo for int {
-    fn bar() {} //~ ERROR method `bar` is declared as static in its trait, but not in its impl
+    fn bar(&self) {} //~ ERROR method `bar` is declared as static in its trait, but not in its impl
 }
 
 fn main() {}

src/test/compile-fail/tps-invariant-trait.rs

@@ -9,8 +9,8 @@
 // except according to those terms.
 
 trait box_trait<T> {
-    fn get() -> T;
-    fn set(t: T);
+    fn get(&self) -> T;
+    fn set(&self, t: T);
 }
 
 struct box<T> {
@@ -20,8 +20,8 @@ struct box<T> {
 struct box_impl<T>(box<T>);
 
 impl<T:Copy> box_trait<T> for box_impl<T> {
-    fn get() -> T { return self.f; }
-    fn set(t: T) { self.f = t; }
+    fn get(&self) -> T { return self.f; }
+    fn set(&self, t: T) { self.f = t; }
 }
 
 fn set_box_trait<T>(b: @box_trait<@const T>, v: @const T) {

src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs

@@ -11,7 +11,7 @@
 trait A { }
 
 impl A for int {
-    fn foo() { } //~ ERROR method `foo` is not a member of trait `A`
+    fn foo(&self) { } //~ ERROR method `foo` is not a member of trait `A`
 }
 
 fn main() { }

src/test/compile-fail/trait-impl-different-num-params.rs

@@ -9,10 +9,10 @@
 // except according to those terms.
 
 trait foo {
-    fn bar(x: uint) -> Self;
+    fn bar(&self, x: uint) -> Self;
 }
 impl foo for int {
-    fn bar() -> int {
+    fn bar(&self) -> int {
         //~^ ERROR method `bar` has 0 parameters but the trait has 1
         self
     }

src/test/compile-fail/trait-or-new-type-instead.rs

@@ -10,7 +10,7 @@
 
 // error-pattern: implement a trait or new type instead
 pub impl <T> Option<T> {
-    fn foo() { }
+    fn foo(&self) { }
 }
 
 fn main() { }

src/test/compile-fail/trait-test-2.rs

@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait bar { fn dup() -> Self; fn blah<X>(); }
-impl bar for int { fn dup() -> int { self } fn blah<X>() {} }
-impl bar for uint { fn dup() -> uint { self } fn blah<X>() {} }
+trait bar { fn dup(&self) -> Self; fn blah<X>(); }
+impl bar for int { fn dup(&self) -> int { self } fn blah<X>() {} }
+impl bar for uint { fn dup(&self) -> uint { self } fn blah<X>() {} }
 
 fn main() {
     10i.dup::<int>(); //~ ERROR does not take type parameters

src/test/compile-fail/trait-test.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait foo { fn foo(); }
+trait foo { fn foo(&self); }
 
-impl int for uint { fn foo() {} } //~ ERROR trait
+impl int for uint { fn foo(&self) {} } //~ ERROR trait
 
 fn main() {}

src/test/compile-fail/vtable-res-trait-param.rs

@@ -9,15 +9,15 @@
 // except according to those terms.
 
 trait TraitA {
-    fn method_a() -> int;
+    fn method_a(&self) -> int;
 }
 
 trait TraitB {
-    fn gimme_an_a<A:TraitA>(a: A) -> int;
+    fn gimme_an_a<A:TraitA>(&self, a: A) -> int;
 }
 
 impl TraitB for int {
-    fn gimme_an_a<A:TraitA>(a: A) -> int {
+    fn gimme_an_a<A:TraitA>(&self, a: A) -> int {
         a.method_a() + self
     }
 }

src/test/run-fail/unwind-box-trait.rs

@@ -15,11 +15,11 @@ fn failfn() {
 }
 
 trait i {
-    fn foo();
+    fn foo(&self);
 }
 
 impl i for ~int {
-    fn foo() { }
+    fn foo(&self) { }
 }
 
 fn main() {

src/test/run-pass/assignability-trait.rs

@@ -13,11 +13,11 @@
 // it.
 
 trait iterable<A> {
-    fn iterate(blk: &fn(x: &A) -> bool);
+    fn iterate(&self, blk: &fn(x: &A) -> bool);
 }
 
 impl<A> iterable<A> for &self/[A] {
-    fn iterate(f: &fn(x: &A) -> bool) {
+    fn iterate(&self, f: &fn(x: &A) -> bool) {
         for vec::each(self) |e| {
             if !f(e) { break; }
         }
@@ -25,7 +25,7 @@ impl<A> iterable<A> for &self/[A] {
 }
 
 impl<A> iterable<A> for ~[A] {
-    fn iterate(f: &fn(x: &A) -> bool) {
+    fn iterate(&self, f: &fn(x: &A) -> bool) {
         for vec::each(self) |e| {
             if !f(e) { break; }
         }

src/test/run-pass/auto-ref.rs

@@ -13,11 +13,11 @@ struct Foo {
 }
 
 trait Stuff {
-    fn printme();
+    fn printme(self);
 }
 
 impl Stuff for &self/Foo {
-    fn printme() {
+    fn printme(self) {
         io::println(fmt!("%d", self.x));
     }
 }

src/test/run-pass/autoderef-method-newtype.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait double {
-    fn double() -> uint;
+    fn double(&self) -> uint;
 }
 
 impl double for uint {
-    fn double() -> uint { self * 2u }
+    fn double(&self) -> uint { *self * 2u }
 }
 
 struct foo(uint);

src/test/run-pass/autoderef-method-on-trait.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait double {
-    fn double() -> uint;
+    fn double(self) -> uint;
 }
 
 impl double for uint {
-    fn double() -> uint { self * 2u }
+    fn double(self) -> uint { self * 2u }
 }
 
 pub fn main() {

src/test/run-pass/autoderef-method-priority.rs

@@ -9,15 +9,15 @@
 // except according to those terms.
 
 trait double {
-    fn double() -> uint;
+    fn double(self) -> uint;
 }
 
 impl double for uint {
-    fn double() -> uint { self }
+    fn double(self) -> uint { self }
 }
 
 impl double for @uint {
-    fn double() -> uint { *self * 2u }
+    fn double(self) -> uint { *self * 2u }
 }
 
 pub fn main() {

src/test/run-pass/autoderef-method-twice-but-not-thrice.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait double {
-    fn double() -> uint;
+    fn double(self) -> uint;
 }
 
 impl double for @@uint {
-    fn double() -> uint { **self * 2u }
+    fn double(self) -> uint { **self * 2u }
 }
 
 pub fn main() {

src/test/run-pass/autoderef-method-twice.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait double {
-    fn double() -> uint;
+    fn double(self) -> uint;
 }
 
 impl double for uint {
-    fn double() -> uint { self * 2u }
+    fn double(self) -> uint { self * 2u }
 }
 
 pub fn main() {

src/test/run-pass/autoderef-method.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait double {
-    fn double() -> uint;
+    fn double(self) -> uint;
 }
 
 impl double for uint {
-    fn double() -> uint { self * 2u }
+    fn double(self) -> uint { self * 2u }
 }
 
 pub fn main() {

src/test/run-pass/borrowck-newtype-issue-2573.rs

@@ -15,11 +15,11 @@ struct baz_ {baz: int}
 type baz = @mut baz_;
 
 trait frob {
-    fn frob();
+    fn frob(&self);
 }
 
 impl frob for foo {
-    fn frob() {
+    fn frob(&self) {
         really_impure(self.bar);
     }
 }

src/test/run-pass/boxed-trait-with-vstore.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait Foo {
-    fn foo();
+    fn foo(self);
 }
 
 impl Foo for int {
-    fn foo() {
+    fn foo(self) {
         io::println("Hello world!");
     }
 }

src/test/run-pass/class-cast-to-trait-multiple-types.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait noisy {
-  fn speak() -> int;
+  fn speak(&self) -> int;
 }
 
 struct dog {
@@ -19,7 +19,7 @@ struct dog {
 }
 
 pub impl dog {
-    priv fn bark() -> int {
+    priv fn bark(&self) -> int {
       debug!("Woof %u %d", *self.barks, *self.volume);
       *self.barks += 1u;
       if *self.barks % 3u == 0u {
@@ -34,7 +34,7 @@ pub impl dog {
 }
 
 impl noisy for dog {
-  fn speak() -> int { self.bark() }
+  fn speak(&self) -> int { self.bark() }
 }
 
 fn dog() -> dog {
@@ -52,15 +52,15 @@ struct cat {
 }
 
 impl noisy for cat {
-  fn speak() -> int { self.meow() as int }
+  fn speak(&self) -> int { self.meow() as int }
 }
 
 pub impl cat {
-  fn meow_count() -> uint { *self.meows }
+  fn meow_count(&self) -> uint { *self.meows }
 }
 
 priv impl cat {
-    fn meow() -> uint {
+    fn meow(&self) -> uint {
       debug!("Meow");
       *self.meows += 1u;
       if *self.meows % 5u == 0u {

src/test/run-pass/class-exports.rs

@@ -22,10 +22,10 @@ mod kitty {
     }
 
     pub impl cat {
-        fn get_name() -> ~str { copy self.name }
+        fn get_name(&self) -> ~str { copy self.name }
     }
 
-    pub fn cat(in_name: ~str) -> cat {
+    pub fn cat(&self, in_name: ~str) -> cat {
         cat {
             name: in_name,
             meows: 0u

src/test/run-pass/conditional-compile.rs

@@ -137,25 +137,25 @@ mod test_methods {
 
     impl Fooable for Foo {
         #[cfg(bogus)]
-        static fn what() { }
+        static fn what(&self) { }
 
-        static fn what() { }
+        static fn what(&self) { }
 
         #[cfg(bogus)]
-        fn the() { }
+        fn the(&self) { }
 
-        fn the() { }
+        fn the(&self) { }
     }
 
     trait Fooable {
         #[cfg(bogus)]
-        static fn what();
+        static fn what(&self);
 
-        static fn what();
+        static fn what(&self);
 
         #[cfg(bogus)]
-        fn the();
+        fn the(&self);
 
-        fn the();
+        fn the(&self);
     }
 }

src/test/run-pass/default-method-simple.rs

@@ -11,11 +11,11 @@
 #[allow(default_methods)];
 
 trait Foo {
-    fn f() {
+    fn f(&self) {
         io::println("Hello!");
         self.g();
     }
-    fn g();
+    fn g(&self);
 }
 
 struct A {
@@ -23,7 +23,7 @@ struct A {
 }
 
 impl Foo for A {
-    fn g() {
+    fn g(&self) {
         io::println("Goodbye!");
     }
 }

src/test/run-pass/early-vtbl-resolution.rs

@@ -10,10 +10,10 @@
 
 
 trait thing<A> {
-    fn foo() -> Option<A>;
+    fn foo(&self) -> Option<A>;
 }
 impl<A> thing<A> for int {
-    fn foo() -> Option<A> { None }
+    fn foo(&self) -> Option<A> { None }
 }
 fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
 

src/test/run-pass/generic-object.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait Foo<T> {
-    fn get() -> T;
+    fn get(&self) -> T;
 }
 
 struct S {
@@ -17,7 +17,7 @@ struct S {
 }
 
 impl Foo<int> for S {
-    fn get() -> int {
+    fn get(&self) -> int {
         self.x
     }
 }

src/test/run-pass/impl-implicit-trait.rs

@@ -14,7 +14,7 @@ enum option_<T> {
 }
 
 pub impl<T> option_<T> {
-    fn foo() -> bool { true }
+    fn foo(&self) -> bool { true }
 }
 
 enum option__ {
@@ -23,7 +23,7 @@ enum option__ {
 }
 
 pub impl option__ {
-    fn foo() -> bool { true }
+    fn foo(&self) -> bool { true }
 }
 
 pub fn main() {

src/test/run-pass/impl-variance.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait foo {
-    fn foo() -> uint;
+    fn foo(&self) -> uint;
 }
 
 impl<T> foo for ~[const T] {
-    fn foo() -> uint { vec::len(self) }
+    fn foo(&self) -> uint { vec::len(self) }
 }
 
 pub fn main() {

src/test/run-pass/issue-2284.rs

@@ -9,11 +9,11 @@
 // except according to those terms.
 
 trait Send {
-    fn f();
+    fn f(&self);
 }
 
 fn f<T:Send>(t: T) {
-    t.f();
+    t.f(&self);
 }
 
 pub fn main() {

src/test/run-pass/issue-2288.rs

@@ -9,14 +9,14 @@
 // except according to those terms.
 
 trait c lam<A:Copy> {
-  fn chowder(y: A);
+  fn chowder(&self, y: A);
 }
 struct foo<A> {
   x: A,
 }
 
 impl<A:Copy> clam<A> for foo<A> {
-  fn chowder(y: A) {
+  fn chowder(&self, y: A) {
   }
 }
 

src/test/run-pass/issue-2311-2.rs

@@ -14,7 +14,7 @@ struct foo<A> {
 }
 
 pub impl<A:Copy> foo<A> {
-   fn bar<B,C:clam<A>>(c: C) -> B {
+   fn bar<B,C:clam<A>>(&self, c: C) -> B {
      fail!();
    }
 }

src/test/run-pass/issue-2311.rs

@@ -10,7 +10,7 @@
 
 trait clam<A> { }
 trait foo<A> {
-   fn bar<B,C:clam<A>>(c: C) -> B;
+   fn bar<B,C:clam<A>>(&self, c: C) -> B;
 }
 
 pub fn main() { }

src/test/run-pass/issue-2312.rs

@@ -15,7 +15,7 @@ trait clam<A> { }
 struct foo(int);
 
 pub impl foo {
-    fn bar<B,C:clam<B>>(c: C) -> B { fail!(); }
+    fn bar<B,C:clam<B>>(&self, c: C) -> B { fail!(); }
 }
 
 pub fn main() { }

src/test/run-pass/issue-2445-b.rs

@@ -13,7 +13,7 @@ struct c1<T> {
 }
 
 pub impl<T:Copy> c1<T> {
-    fn f1(x: int) {
+    fn f1(&self, x: int) {
     }
 }
 
@@ -24,7 +24,7 @@ fn c1<T:Copy>(x: T) -> c1<T> {
 }
 
 pub impl<T:Copy> c1<T> {
-    fn f2(x: int) {
+    fn f2(&self, x: int) {
     }
 }
 

src/test/run-pass/issue-2445.rs

@@ -13,7 +13,7 @@ struct c1<T> {
 }
 
 pub impl<T:Copy> c1<T> {
-    fn f1(x: T) {}
+    fn f1(&self, x: T) {}
 }
 
 fn c1<T:Copy>(x: T) -> c1<T> {
@@ -23,7 +23,7 @@ fn c1<T:Copy>(x: T) -> c1<T> {
 }
 
 pub impl<T:Copy> c1<T> {
-    fn f2(x: T) {}
+    fn f2(&self, x: T) {}
 }
 
 

src/test/run-pass/issue-2487-a.rs

@@ -18,8 +18,7 @@ impl Drop for socket {
 }
 
 pub impl socket {
-
-    fn set_identity()  {
+    fn set_identity(&self)  {
         do closure {
             setsockopt_bytes(copy self.sock)
         }

src/test/run-pass/issue-2502.rs

@@ -13,7 +13,7 @@ struct font {
 }
 
 pub impl font/&self {
-    fn buf() -> &self/~[u8] {
+    fn buf(&self) -> &self/~[u8] {
         self.fontbuf
     }
 }

src/test/run-pass/issue-2734.rs

@@ -11,7 +11,7 @@
 trait hax { } 
 impl<A> hax for A { } 
 
-fn perform_hax<T:&static>(x: @T) -> hax {
+fn perform_hax<T:&static>(x: @T) -> @hax {
     @x as @hax
 }
 

src/test/run-pass/issue-2935.rs

@@ -13,11 +13,11 @@
 type t = bool;
 
 trait it {
-    fn f();
+    fn f(&self);
 }
 
 impl it for t {
-    fn f() { }
+    fn f(&self) { }
 }
 
 pub fn main() {

src/test/run-pass/issue-2936.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait bar<T> {
-    fn get_bar() -> T;
+    fn get_bar(&self) -> T;
 }
 
 fn foo<T, U: bar<T>>(b: U) -> T {
@@ -21,7 +21,7 @@ struct cbar {
 }
 
 impl bar<int> for cbar {
-    fn get_bar() -> int {
+    fn get_bar(&self) -> int {
         self.x
     }
 }

src/test/run-pass/issue-2989.rs

@@ -11,11 +11,11 @@
 extern mod std;
 
 trait methods {
-    fn to_bytes() -> ~[u8];
+    fn to_bytes(&self) -> ~[u8];
 }
 
 impl methods for () {
-    fn to_bytes() -> ~[u8] {
+    fn to_bytes(&self) -> ~[u8] {
         vec::from_elem(0, 0)
     }
 }

src/test/run-pass/issue-3563-2.rs

@@ -10,8 +10,8 @@
 
 #[allow(default_methods)]
 trait Canvas {
-    fn add_point(point: &int);
-    fn add_points(shapes: &[int]) {
+    fn add_point(&self, point: &int);
+    fn add_points(&self, shapes: &[int]) {
         for shapes.each |pt| {
             self.add_point(pt)
         }

src/test/run-pass/issue-3683.rs

@@ -11,14 +11,14 @@
 #[allow(default_methods)];
 
 trait Foo {
-    fn a() -> int;
-    fn b() -> int {
+    fn a(&self) -> int;
+    fn b(&self) -> int {
         self.a() + 2
     }
 }
 
 impl Foo for int {
-    fn a() -> int {
+    fn a(&self) -> int {
         3
     }
 }

src/test/run-pass/issue-3753.rs

@@ -23,7 +23,7 @@ pub enum Shape {
 }
 
 pub impl Shape {
-    pub fn area(sh: Shape) -> float {
+    pub fn area(&self, sh: Shape) -> float {
         match sh {
             Circle(_, size) => float::consts::pi * size * size,
             Rectangle(Point {x, y}, Point {x: x2, y: y2}) => (x2 - x) * (y2 - y)

src/test/run-pass/kindck-owned-trait-contains-1.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait repeat<A> { fn get() -> A; }
+trait repeat<A> { fn get(&self) -> A; }
 
 impl<A:Copy> repeat<A> for @A {
-    fn get() -> A { *self }
+    fn get(&self) -> A { *self }
 }
 
 fn repeater<A:Copy>(v: @A) -> @repeat<A> {

src/test/run-pass/max-min-classes.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 trait Product {
-    fn product() -> int;
+    fn product(&self) -> int;
 }
 
 struct Foo {
@@ -18,13 +18,13 @@ struct Foo {
 }
 
 pub impl Foo {
-    fn sum() -> int {
+    fn sum(&self) -> int {
         self.x + self.y
     }
 }
 
 impl Product for Foo {
-    fn product() -> int {
+    fn product(&self) -> int {
         self.x * self.y
     }
 }

src/test/run-pass/method-attributes.rs

@@ -13,20 +13,20 @@
 #[frobable]
 trait frobable {
     #[frob_attr]
-    fn frob();
+    fn frob(&self);
     #[defrob_attr]
-    fn defrob();
+    fn defrob(&self);
 }
 
 #[int_frobable]
 impl frobable for int {
     #[frob_attr1]
-    fn frob() {
+    fn frob(&self) {
         #[frob_attr2];
     }
 
     #[defrob_attr1]
-    fn defrob() {
+    fn defrob(&self) {
         #[defrob_attr2];
     }
 }

src/test/run-pass/monad.rs

@@ -11,11 +11,11 @@
 // xfail-fast
 
 trait vec_monad<A> {
-    fn bind<B:Copy>(f: &fn(&A) -> ~[B]) -> ~[B];
+    fn bind<B:Copy>(&self, f: &fn(&A) -> ~[B]) -> ~[B];
 }
 
 impl<A> vec_monad<A> for ~[A] {
-    fn bind<B:Copy>(f: &fn(&A) -> ~[B]) -> ~[B] {
+    fn bind<B:Copy>(&self, f: &fn(&A) -> ~[B]) -> ~[B] {
         let mut r = ~[];
         for self.each |elt| { r += f(elt); }
         r
@@ -23,11 +23,11 @@ impl<A> vec_monad<A> for ~[A] {
 }
 
 trait option_monad<A> {
-    fn bind<B>(f: &fn(&A) -> Option<B>) -> Option<B>;
+    fn bind<B>(&self, f: &fn(&A) -> Option<B>) -> Option<B>;
 }
 
 impl<A> option_monad<A> for Option<A> {
-    fn bind<B>(f: &fn(&A) -> Option<B>) -> Option<B> {
+    fn bind<B>(&self, f: &fn(&A) -> Option<B>) -> Option<B> {
         match self {
           Some(ref a) => { f(a) }
           None => { None }

src/test/run-pass/monomorphize-trait-in-fn-at.rs

@@ -17,11 +17,11 @@ fn mk_nil<C:ty_ops>(cx: C) -> uint {
 }
 
 trait ty_ops {
-    fn mk() -> uint;
+    fn mk(&self) -> uint;
 }
 
 impl ty_ops for () {
-    fn mk() -> uint { 22u }
+    fn mk(&self) -> uint { 22u }
 }
 
 pub fn main() {