Add manual &self/ and &static/ and /&self declarations that

are currently inferred.  New rules are coming that will require
them to be explicit.  All add some explicit self declarations.

Author: nikomatsakis

doc/rust.md

@@ -1144,22 +1144,23 @@ Constants are declared with the `const` keyword.
 A constant item must have an expression giving its definition.
 The definition expression of a constant is limited to expression forms that can be evaluated at compile time.
 
-Constants must be explicitly typed. The type may be ```bool```, ```char```, a number, or a type derived from
-those primitive types. The derived types are borrowed pointers, static arrays, tuples, and structs.
+Constants must be explicitly typed. The type may be ```bool```, ```char```, a number, or a type derived from those primitive types.
+The derived types are borrowed pointers, static arrays, tuples, and structs.
+Borrowed pointers must be have the `'static` lifetime.
 
 ~~~~
 const bit1: uint = 1 << 0;
 const bit2: uint = 1 << 1;
 
 const bits: [uint * 2] = [bit1, bit2];
-const string: &str = "bitstring";
+const string: &'static str = "bitstring";
 
 struct BitsNStrings {
     mybits: [uint *2],
-    mystring: &str
+    mystring: &'self str
 }
 
-const bits_n_strings: BitsNStrings = BitsNStrings {
+const bits_n_strings: BitsNStrings<'static> = BitsNStrings {
     mybits: bits,
     mystring: string
 };
@@ -1630,7 +1631,7 @@ The following are examples of structure expressions:
 ~~~~
 # struct Point { x: float, y: float }
 # struct TuplePoint(float, float);
-# mod game { pub struct User { name: &str, age: uint, score: uint } }
+# mod game { pub struct User<'self> { name: &'self str, age: uint, score: uint } }
 # struct Cookie; fn some_fn<T>(t: T) {}
 Point {x: 10f, y: 20f};
 TuplePoint(10f, 20f);
@@ -2556,8 +2557,8 @@ order specified by the tuple type.
 An example of a tuple type and its use:
 
 ~~~~
-type Pair = (int,&str);
-let p: Pair = (10,"hello");
+type Pair<'self> = (int,&'self str);
+let p: Pair<'static> = (10,"hello");
 let (a, b) = p;
 assert b != "world";
 ~~~~
@@ -2718,7 +2719,7 @@ fn add(x: int, y: int) -> int {
 
 let mut x = add(5,7);
 
-type Binop = fn(int,int) -> int;
+type Binop<'self> = &'self fn(int,int) -> int;
 let bo: Binop = add;
 x = bo(5,7);
 ~~~~~~~~

doc/tutorial.md

@@ -1951,7 +1951,7 @@ trait Printable {
 Traits may be implemented for specific types with [impls]. An impl
 that implements a trait includes the name of the trait at the start of
 the definition, as in the following impls of `Printable` for `int`
-and `&str`.
+and `~str`.
 
 [impls]: #functions-and-methods
 
@@ -1961,12 +1961,12 @@ impl Printable for int {
     fn print(&self) { io::println(fmt!("%d", *self)) }
 }
 
-impl Printable for &str {
+impl Printable for ~str {
     fn print(&self) { io::println(*self) }
 }
 
 # 1.print();
-# ("foo").print();
+# (~"foo").print();
 ~~~~
 
 Methods defined in an implementation of a trait may be called just like

src/libcore/at_vec.rs

@@ -168,7 +168,7 @@ pub mod traits {
     use kinds::Copy;
     use ops::Add;
 
-    impl<T:Copy> Add<&[const T],@[T]> for @[T] {
+    impl<T:Copy> Add<&self/[const T],@[T]> for @[T] {
         #[inline(always)]
         pure fn add(&self, rhs: & &self/[const T]) -> @[T] {
             append(*self, (*rhs))

src/libcore/cleanup.rs

@@ -22,8 +22,8 @@ use cast::transmute;
  * NB: These must match the representation in the C++ runtime.
  */
 
-type DropGlue = fn(**TypeDesc, *c_void);
-type FreeGlue = fn(**TypeDesc, *c_void);
+type DropGlue = &self/fn(**TypeDesc, *c_void);
+type FreeGlue = &self/fn(**TypeDesc, *c_void);
 
 type TaskID = uintptr_t;
 

src/libcore/condition.rs

@@ -22,10 +22,10 @@ pub struct Handler<T, U> {
 
 pub struct Condition<T, U> {
     name: &static/str,
-    key: task::local_data::LocalDataKey<Handler<T, U>>
+    key: task::local_data::LocalDataKey/&self<Handler<T, U>>
 }
 
-pub impl<T, U> Condition<T, U> {
+pub impl<T, U> Condition/&self<T, U> {
     fn trap(&self, h: &self/fn(T) -> U) -> Trap/&self<T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
@@ -65,11 +65,11 @@ pub impl<T, U> Condition<T, U> {
 }
 
 struct Trap<T, U> {
-    cond: &Condition<T, U>,
+    cond: &self/Condition/&self<T, U>,
     handler: @Handler<T, U>
 }
 
-pub impl<T, U> Trap<T, U> {
+pub impl<T, U> Trap/&self<T, U> {
     fn in<V>(&self, inner: &self/fn() -> V) -> V {
         unsafe {
             let _g = Guard { cond: self.cond };
@@ -81,10 +81,10 @@ pub impl<T, U> Trap<T, U> {
 }
 
 struct Guard<T, U> {
-    cond: &Condition<T, U>
+    cond: &self/Condition/&self<T, U>
 }
 
-impl<T, U> Drop for Guard<T, U> {
+impl<T, U> Drop for Guard/&self<T, U> {
     fn finalize(&self) {
         unsafe {
             debug!("Guard: popping handler from TLS");

src/libcore/container.rs

@@ -10,7 +10,6 @@
 
 //! Container traits
 
-use cmp::Equiv;
 use option::Option;
 
 pub trait Container {

src/libcore/gc.rs

@@ -115,7 +115,7 @@ unsafe fn is_safe_point(pc: *Word) -> Option<SafePoint> {
     return None;
 }
 
-type Visitor = fn(root: **Word, tydesc: *Word) -> bool;
+type Visitor = &self/fn(root: **Word, tydesc: *Word) -> bool;
 
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.

src/libcore/hash.rs

@@ -298,7 +298,7 @@ impl io::Writer for SipState {
     }
 }
 
-impl Streaming for &SipState {
+impl Streaming for SipState {
 
     #[inline(always)]
     fn input(&self, buf: &[const u8]) {

src/libcore/hashmap.rs

@@ -268,7 +268,9 @@ pub mod linear {
         }
     }
 
-    impl<K:Hash + IterBytes + Eq,V> BaseIter<(&K, &V)> for LinearMap<K, V> {
+    impl<K:Hash + IterBytes + Eq,V>
+        BaseIter<(&self/K, &self/V)> for LinearMap<K, V>
+    {
         /// Visit all key-value pairs
         pure fn each(&self, blk: fn(&(&self/K, &self/V)) -> bool) {
             for uint::range(0, self.buckets.len()) |i| {

src/libcore/io.rs

@@ -585,11 +585,11 @@ pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
 
 // Byte readers
 pub struct BytesReader {
-    bytes: &[u8],
+    bytes: &self/[u8],
     mut pos: uint
 }
 
-impl Reader for BytesReader {
+impl Reader for BytesReader/&self {
     fn read(&self, bytes: &mut [u8], len: uint) -> uint {
         let count = uint::min(len, self.bytes.len() - self.pos);