librustc: Convert all uses of old lifetime notation to new lifetime notation. rs=delifetiming

src/libcore/at_vec.rs

@@ -174,9 +174,9 @@ pub mod traits {
     use kinds::Copy;
     use ops::Add;
 
-    impl<T:Copy> Add<&self/[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] {
+        pure fn add(&self, rhs: & &'self [const T]) -> @[T] {
             append(*self, (*rhs))
         }
     }

src/libcore/cast.rs

@@ -59,17 +59,17 @@ pub unsafe fn transmute<L, G>(thing: L) -> G {
 
 /// Coerce an immutable reference to be mutable.
 #[inline(always)]
-pub unsafe fn transmute_mut<T>(ptr: &a/T) -> &a/mut T { transmute(ptr) }
+pub unsafe fn transmute_mut<T>(ptr: &'a T) -> &'a mut T { transmute(ptr) }
 
 /// Coerce a mutable reference to be immutable.
 #[inline(always)]
-pub unsafe fn transmute_immut<T>(ptr: &a/mut T) -> &a/T {
+pub unsafe fn transmute_immut<T>(ptr: &'a mut T) -> &'a T {
     transmute(ptr)
 }
 
 /// Coerce a borrowed pointer to have an arbitrary associated region.
 #[inline(always)]
-pub unsafe fn transmute_region<T>(ptr: &a/T) -> &b/T { transmute(ptr) }
+pub unsafe fn transmute_region<T>(ptr: &'a T) -> &'b T { transmute(ptr) }
 
 /// Coerce an immutable reference to be mutable.
 #[inline(always)]
@@ -85,19 +85,19 @@ pub unsafe fn transmute_immut_unsafe<T>(ptr: *const T) -> *T {
 
 /// Coerce a borrowed mutable pointer to have an arbitrary associated region.
 #[inline(always)]
-pub unsafe fn transmute_mut_region<T>(ptr: &a/mut T) -> &b/mut T {
+pub unsafe fn transmute_mut_region<T>(ptr: &'a mut T) -> &'b mut T {
     transmute(ptr)
 }
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline(always)]
-pub unsafe fn copy_lifetime<S,T>(_ptr: &a/S, ptr: &T) -> &a/T {
+pub unsafe fn copy_lifetime<S,T>(_ptr: &'a S, ptr: &T) -> &'a T {
     transmute_region(ptr)
 }
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline(always)]
-pub unsafe fn copy_lifetime_vec<S,T>(_ptr: &a/[S], ptr: &T) -> &a/T {
+pub unsafe fn copy_lifetime_vec<S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
     transmute_region(ptr)
 }
 

src/libcore/cleanup.rs

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

src/libcore/condition.rs

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

src/libcore/container.rs

@@ -39,7 +39,7 @@ pub trait Map<K, V>: Mutable {
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
 
     /// Return the value corresponding to the key in the map
-    pure fn find(&self, key: &K) -> Option<&self/V>;
+    pure fn find(&self, key: &K) -> Option<&'self V>;
 
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did

src/libcore/gc.rs

@@ -122,7 +122,7 @@ unsafe fn is_safe_point(pc: *Word) -> Option<SafePoint> {
     return None;
 }
 
-type Visitor = &self/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/hashmap.rs

@@ -185,7 +185,7 @@ pub mod linear {
         }
 
         #[inline(always)]
-        pure fn value_for_bucket(&self, idx: uint) -> &self/V {
+        pure fn value_for_bucket(&self, idx: uint) -> &'self V {
             match self.buckets[idx] {
                 Some(ref bkt) => &bkt.value,
                 None => fail!(~"LinearMap::find: internal logic error"),
@@ -270,10 +270,10 @@ pub mod linear {
     }
 
     impl<K:Hash + IterBytes + Eq,V>
-        BaseIter<(&self/K, &self/V)> for LinearMap<K, 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) {
+        pure fn each(&self, blk: &fn(&(&'self K, &'self V)) -> bool) {
             for uint::range(0, self.buckets.len()) |i| {
                 let mut broke = false;
                 do self.buckets[i].map |bucket| {
@@ -339,7 +339,7 @@ pub mod linear {
         }
 
         /// Return the value corresponding to the key in the map
-        pure fn find(&self, k: &K) -> Option<&self/V> {
+        pure fn find(&self, k: &K) -> Option<&'self V> {
             match self.bucket_for_key(k) {
                 FoundEntry(idx) => Some(self.value_for_bucket(idx)),
                 TableFull | FoundHole(_) => None,
@@ -412,7 +412,7 @@ pub mod linear {
 
         /// Return the value corresponding to the key in the map, or insert
         /// and return the value if it doesn't exist.
-        fn find_or_insert(&mut self, k: K, v: V) -> &self/V {
+        fn find_or_insert(&mut self, k: K, v: V) -> &'self V {
             if self.size >= self.resize_at {
                 // n.b.: We could also do this after searching, so
                 // that we do not resize if this call to insert is
@@ -442,7 +442,7 @@ pub mod linear {
 
         /// Return the value corresponding to the key in the map, or create,
         /// insert, and return a new value if it doesn't exist.
-        fn find_or_insert_with(&mut self, k: K, f: &fn(&K) -> V) -> &self/V {
+        fn find_or_insert_with(&mut self, k: K, f: &fn(&K) -> V) -> &'self V {
             if self.size >= self.resize_at {
                 // n.b.: We could also do this after searching, so
                 // that we do not resize if this call to insert is
@@ -487,7 +487,7 @@ pub mod linear {
             }
         }
 
-        pure fn get(&self, k: &K) -> &self/V {
+        pure fn get(&self, k: &K) -> &'self V {
             match self.find(k) {
                 Some(v) => v,
                 None => fail!(fmt!("No entry found for key: %?", k)),
@@ -509,7 +509,7 @@ pub mod linear {
         /// Return the value corresponding to the key in the map, using
         /// equivalence
         pure fn find_equiv<Q:Hash + IterBytes + Equiv<K>>(&self, k: &Q)
-                                                       -> Option<&self/V> {
+                                                       -> Option<&'self V> {
             match self.bucket_for_key_equiv(k) {
                 FoundEntry(idx) => Some(self.value_for_bucket(idx)),
                 TableFull | FoundHole(_) => None,

src/libcore/io.rs

@@ -589,7 +589,7 @@ pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
 
 // Byte readers
 pub struct BytesReader {
-    bytes: &self/[u8],
+    bytes: &'self [u8],
     mut pos: uint
 }
 

src/libcore/iter.rs

@@ -20,7 +20,7 @@ use option::{None, Option, Some};
 use vec;
 
 /// A function used to initialize the elements of a sequence
-pub type InitOp<T> = &self/fn(uint) -> T;
+pub type InitOp<T> = &'self fn(uint) -> T;
 
 pub trait BaseIter<A> {
     pure fn each(&self, blk: &fn(v: &A) -> bool);

src/libcore/option.rs

@@ -122,7 +122,7 @@ pub pure fn get<T:Copy>(opt: Option<T>) -> T {
 }
 
 #[inline(always)]
-pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
+pub pure fn get_ref<T>(opt: &'r Option<T>) -> &'r T {
     /*!
     Gets an immutable reference to the value inside an option.
 
@@ -143,7 +143,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
     }
 }
 
-pub pure fn get_mut_ref<T>(opt: &r/mut Option<T>) -> &r/mut T {
+pub pure fn get_mut_ref<T>(opt: &'r mut Option<T>) -> &'r mut T {
     /*!
     Gets a mutable reference to the value inside an option.
 
@@ -165,7 +165,7 @@ pub pure fn get_mut_ref<T>(opt: &r/mut Option<T>) -> &r/mut T {
 }
 
 #[inline(always)]
-pub pure fn map<T, U>(opt: &r/Option<T>, f: &fn(x: &r/T) -> U) -> Option<U> {
+pub pure fn map<T, U>(opt: &'r Option<T>, f: &fn(x: &'r T) -> U) -> Option<U> {
     //! Maps a `some` value by reference from one type to another
 
     match *opt { Some(ref x) => Some(f(x)), None => None }
@@ -256,8 +256,8 @@ pub pure fn get_or_default<T:Copy>(opt: Option<T>, def: T) -> T {
 }
 
 #[inline(always)]
-pub pure fn map_default<T, U>(opt: &r/Option<T>, def: U,
+pub pure fn map_default<T, U>(opt: &'r Option<T>, def: U,
-                              f: &fn(&r/T) -> U) -> U {
+                              f: &fn(&'r T) -> U) -> U {
     //! Applies a function to the contained value or returns a default
 
     match *opt { None => def, Some(ref t) => f(t) }
@@ -313,7 +313,7 @@ pub pure fn expect<T>(opt: Option<T>, reason: &str) -> T {
 impl<T> BaseIter<T> for Option<T> {
     /// Performs an operation on the contained value by reference
     #[inline(always)]
-    pure fn each(&self, f: &fn(x: &self/T) -> bool) {
+    pure fn each(&self, f: &fn(x: &'self T) -> bool) {
         match *self { None => (), Some(ref t) => { f(t); } }
     }
 
@@ -350,7 +350,7 @@ pub impl<T> Option<T> {
 
     /// Maps a `some` value from one type to another by reference
     #[inline(always)]
-    pure fn map<U>(&self, f: &fn(&self/T) -> U) -> Option<U> { map(self, f) }
+    pure fn map<U>(&self, f: &fn(&'self T) -> U) -> Option<U> { map(self, f) }
 
     /// As `map`, but consumes the option and gives `f` ownership to avoid
     /// copying.
@@ -361,7 +361,7 @@ pub impl<T> Option<T> {
 
     /// Applies a function to the contained value or returns a default
     #[inline(always)]
-    pure fn map_default<U>(&self, def: U, f: &fn(&self/T) -> U) -> U {
+    pure fn map_default<U>(&self, def: U, f: &fn(&'self T) -> U) -> U {
         map_default(self, def, f)
     }
 
@@ -403,7 +403,7 @@ pub impl<T> Option<T> {
     case explicitly.
      */
     #[inline(always)]
-    pure fn get_ref(&self) -> &self/T { get_ref(self) }
+    pure fn get_ref(&self) -> &'self T { get_ref(self) }
 
     /**
     Gets a mutable reference to the value inside an option.
@@ -420,7 +420,7 @@ pub impl<T> Option<T> {
     case explicitly.
      */
     #[inline(always)]
-    pure fn get_mut_ref(&mut self) -> &self/mut T { get_mut_ref(self) }
+    pure fn get_mut_ref(&mut self) -> &'self mut T { get_mut_ref(self) }
 
     /**
      * Gets the value out of an option without copying.

src/libcore/os.rs

@@ -1170,11 +1170,11 @@ pub mod consts {
     pub use os::consts::windows::*;
 
     pub mod unix {
-        pub const FAMILY: &static/str = "unix";
+        pub const FAMILY: &'static str = "unix";
     }
 
     pub mod windows {
-        pub const FAMILY: &static/str = "windows";
+        pub const FAMILY: &'static str = "windows";
     }
 
     #[cfg(target_os = "macos")]
@@ -1193,38 +1193,38 @@ pub mod consts {
     pub use os::consts::win32::*;
 
     pub mod macos {
-        pub const SYSNAME: &static/str = "macos";
+        pub const SYSNAME: &'static str = "macos";
-        pub const DLL_PREFIX: &static/str = "lib";
+        pub const DLL_PREFIX: &'static str = "lib";
-        pub const DLL_SUFFIX: &static/str = ".dylib";
+        pub const DLL_SUFFIX: &'static str = ".dylib";
-        pub const EXE_SUFFIX: &static/str = "";
+        pub const EXE_SUFFIX: &'static str = "";
     }
 
     pub mod freebsd {
-        pub const SYSNAME: &static/str = "freebsd";
+        pub const SYSNAME: &'static str = "freebsd";
-        pub const DLL_PREFIX: &static/str = "lib";
+        pub const DLL_PREFIX: &'static str = "lib";
-        pub const DLL_SUFFIX: &static/str = ".so";
+        pub const DLL_SUFFIX: &'static str = ".so";
-        pub const EXE_SUFFIX: &static/str = "";
+        pub const EXE_SUFFIX: &'static str = "";
     }
 
     pub mod linux {
-        pub const SYSNAME: &static/str = "linux";
+        pub const SYSNAME: &'static str = "linux";
-        pub const DLL_PREFIX: &static/str = "lib";
+        pub const DLL_PREFIX: &'static str = "lib";
-        pub const DLL_SUFFIX: &static/str = ".so";
+        pub const DLL_SUFFIX: &'static str = ".so";
-        pub const EXE_SUFFIX: &static/str = "";
+        pub const EXE_SUFFIX: &'static str = "";
     }
 
     pub mod android {
-        pub const SYSNAME: &static/str = "android";
+        pub const SYSNAME: &'static str = "android";
-        pub const DLL_PREFIX: &static/str = "lib";
+        pub const DLL_PREFIX: &'static str = "lib";
-        pub const DLL_SUFFIX: &static/str = ".so";
+        pub const DLL_SUFFIX: &'static str = ".so";
-        pub const EXE_SUFFIX: &static/str = "";
+        pub const EXE_SUFFIX: &'static str = "";
     }
 
     pub mod win32 {
-        pub const SYSNAME: &static/str = "win32";
+        pub const SYSNAME: &'static str = "win32";
-        pub const DLL_PREFIX: &static/str = "";
+        pub const DLL_PREFIX: &'static str = "";
-        pub const DLL_SUFFIX: &static/str = ".dll";
+        pub const DLL_SUFFIX: &'static str = ".dll";
-        pub const EXE_SUFFIX: &static/str = ".exe";
+        pub const EXE_SUFFIX: &'static str = ".exe";
     }
 
 

src/libcore/pipes.rs

@@ -446,7 +446,7 @@ pub fn try_recv<T:Owned,Tbuffer:Owned>(p: RecvPacketBuffered<T, Tbuffer>)
     let p = unsafe { &*p_ };
 
     struct DropState {
-        p: &self/PacketHeader,
+        p: &'self PacketHeader,
 
         drop {
             if task::failing() {

src/libcore/ptr.rs

@@ -178,7 +178,7 @@ pub pure fn to_uint<T>(thing: &T) -> uint {
 
 /// Determine if two borrowed pointers point to the same thing.
 #[inline(always)]
-pub pure fn ref_eq<T>(thing: &a/T, other: &b/T) -> bool {
+pub pure fn ref_eq<T>(thing: &'a T, other: &'b T) -> bool {
     to_uint(thing) == to_uint(other)
 }
 
@@ -312,34 +312,34 @@ impl<T> Ord for *const T {
 
 // Equality for region pointers
 #[cfg(notest)]
-impl<T:Eq> Eq for &self/const T {
+impl<T:Eq> Eq for &'self const T {
     #[inline(always)]
-    pure fn eq(&self, other: & &self/const T) -> bool {
+    pure fn eq(&self, other: & &'self const T) -> bool {
         return *(*self) == *(*other);
     }
     #[inline(always)]
-    pure fn ne(&self, other: & &self/const T) -> bool {
+    pure fn ne(&self, other: & &'self const T) -> bool {
         return *(*self) != *(*other);
     }
 }
 
 // Comparison for region pointers
 #[cfg(notest)]
-impl<T:Ord> Ord for &self/const T {
+impl<T:Ord> Ord for &'self const T {
     #[inline(always)]
-    pure fn lt(&self, other: & &self/const T) -> bool {
+    pure fn lt(&self, other: & &'self const T) -> bool {
         *(*self) < *(*other)
     }
     #[inline(always)]
-    pure fn le(&self, other: & &self/const T) -> bool {
+    pure fn le(&self, other: & &'self const T) -> bool {
         *(*self) <= *(*other)
     }
     #[inline(always)]
-    pure fn ge(&self, other: & &self/const T) -> bool {
+    pure fn ge(&self, other: & &'self const T) -> bool {
         *(*self) >= *(*other)
     }
     #[inline(always)]
-    pure fn gt(&self, other: & &self/const T) -> bool {
+    pure fn gt(&self, other: & &'self const T) -> bool {
         *(*self) > *(*other)
     }
 }

src/libcore/reflect.rs

@@ -214,9 +214,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_estr_slice(&self) -> bool {
-        self.align_to::<&static/str>();
+        self.align_to::<&'static str>();
         if ! self.inner.visit_estr_slice() { return false; }
-        self.bump_past::<&static/str>();
+        self.bump_past::<&'static str>();
         true
     }
 
@@ -251,9 +251,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<&static/u8>();
+        self.align_to::<&'static u8>();
         if ! self.inner.visit_rptr(mtbl, inner) { return false; }
-        self.bump_past::<&static/u8>();
+        self.bump_past::<&'static u8>();
         true
     }
 
@@ -285,9 +285,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<&static/[u8]>();
+        self.align_to::<&'static [u8]>();
         if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
-        self.bump_past::<&static/[u8]>();
+        self.bump_past::<&'static [u8]>();
         true
     }
 
@@ -465,9 +465,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_self(&self) -> bool {
-        self.align_to::<&static/u8>();
+        self.align_to::<&'static u8>();
         if ! self.inner.visit_self() { return false; }
-        self.align_to::<&static/u8>();
+        self.align_to::<&'static u8>();
         true
     }
 

src/libcore/result.rs

@@ -53,7 +53,7 @@ pub pure fn get<T:Copy,U>(res: &Result<T, U>) -> T {
  * If the result is an error
  */
 #[inline(always)]
-pub pure fn get_ref<T, U>(res: &a/Result<T, U>) -> &a/T {
+pub pure fn get_ref<T, U>(res: &'a Result<T, U>) -> &'a T {
     match *res {
         Ok(ref t) => t,
         Err(ref the_err) => unsafe {
@@ -229,7 +229,7 @@ pub pure fn map_err<T:Copy,E,F:Copy>(res: &Result<T, E>, op: &fn(&E) -> F)
 
 pub impl<T, E> Result<T, E> {
     #[inline(always)]
-    pure fn get_ref(&self) -> &self/T { get_ref(self) }
+    pure fn get_ref(&self) -> &'self T { get_ref(self) }
 
     #[inline(always)]
     pure fn is_ok(&self) -> bool { is_ok(self) }

src/libcore/rt/io.rs

@@ -22,7 +22,7 @@ pub trait EventLoop {
     fn run(&mut self);
     fn callback(&mut self, ~fn());
     /// The asynchronous I/O services. Not all event loops may provide one
-    fn io(&mut self) -> Option<&self/mut IoFactoryObject>;
+    fn io(&mut self) -> Option<&'self mut IoFactoryObject>;
 }
 
 pub trait IoFactory {

src/libcore/rt/sched.rs

@@ -265,12 +265,12 @@ pub impl Scheduler {
         }
     }
 
-    // XXX: Hack. This should return &self/mut but I don't know how to
+    // XXX: Hack. This should return &'self mut but I don't know how to
     // make the borrowcheck happy
     fn task_from_last_cleanup_job(&mut self) -> &mut Task {
         fail_unless!(!self.cleanup_jobs.is_empty());
-        let last_job: &self/mut CleanupJob = &mut self.cleanup_jobs[0];
+        let last_job: &'self mut CleanupJob = &mut self.cleanup_jobs[0];
-        let last_task: &self/Task = match last_job {
+        let last_task: &'self Task = match last_job {
             &RescheduleTask(~ref task) => task,
             &RecycleTask(~ref task) => task,
             &GiveTask(~ref task, _) => task,
@@ -356,7 +356,7 @@ impl ThreadLocalScheduler {
         }
     }
 
-    fn get_scheduler(&mut self) -> &self/mut Scheduler {
+    fn get_scheduler(&mut self) -> &'self mut Scheduler {
         unsafe {
             let key = match self { &ThreadLocalScheduler(key) => key };
             let mut value: *mut c_void = tls::get(key);

src/libcore/rt/uv.rs

@@ -659,7 +659,7 @@ fn install_watcher_data<H, W: Watcher + NativeHandle<*H>>(watcher: &mut W) {
 }
 
 fn get_watcher_data<H, W: Watcher + NativeHandle<*H>>(
-    watcher: &r/mut W) -> &r/mut WatcherData {
+    watcher: &'r mut W) -> &'r mut WatcherData {
 
     unsafe {
         let data = uvll::get_data_for_uv_handle(watcher.native_handle());

src/libcore/rt/uvio.rs

@@ -69,7 +69,7 @@ impl EventLoop for UvEventLoop {
         }
     }
 
-    fn io(&mut self) -> Option<&self/mut IoFactoryObject> {
+    fn io(&mut self) -> Option<&'self mut IoFactoryObject> {
         Some(&mut self.uvio)
     }
 }
@@ -91,7 +91,7 @@ fn test_callback_run_once() {
 pub struct UvIoFactory(Loop);
 
 pub impl UvIoFactory {
-    fn uv_loop(&mut self) -> &self/mut Loop {
+    fn uv_loop(&mut self) -> &'self mut Loop {
         match self { &UvIoFactory(ref mut ptr) => ptr }
     }
 }

src/libcore/str.rs

@@ -279,7 +279,7 @@ pub fn shift_char(s: &mut ~str) -> char {
  * If the string does not contain any characters
  */
 #[inline]
-pub fn view_shift_char(s: &a/str) -> (char, &a/str) {
+pub fn view_shift_char(s: &'a str) -> (char, &'a str) {
     let CharRange {ch, next} = char_range_at(s, 0u);
     let next_s = unsafe { raw::view_bytes(s, next, len(s)) };
     return (ch, next_s);
@@ -429,7 +429,7 @@ pub pure fn slice(s: &str, begin: uint, end: uint) -> ~str {
  * Fails when `begin` and `end` do not point to valid characters or beyond
  * the last character of the string
  */
-pub pure fn view(s: &a/str, begin: uint, end: uint) -> &a/str {
+pub pure fn view(s: &'a str, begin: uint, end: uint) -> &'a str {
     fail_unless!(is_char_boundary(s, begin));
     fail_unless!(is_char_boundary(s, end));
     unsafe { raw::view_bytes(s, begin, end) }
@@ -530,7 +530,7 @@ pure fn split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
 }
 
 // See Issue #1932 for why this is a naive search
-pure fn iter_matches(s: &a/str, sep: &b/str, f: &fn(uint, uint)) {
+pure fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
     let sep_len = len(sep), l = len(s);
     fail_unless!(sep_len > 0u);
     let mut i = 0u, match_start = 0u, match_i = 0u;
@@ -557,7 +557,7 @@ pure fn iter_matches(s: &a/str, sep: &b/str, f: &fn(uint, uint)) {
     }
 }
 
-pure fn iter_between_matches(s: &a/str, sep: &b/str, f: &fn(uint, uint)) {
+pure fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
     let mut last_end = 0u;
     do iter_matches(s, sep) |from, to| {
         f(last_end, from);
@@ -575,7 +575,7 @@ pure fn iter_between_matches(s: &a/str, sep: &b/str, f: &fn(uint, uint)) {
  * fail_unless!(["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", "."))
  * ~~~
  */
-pub pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] {
+pub pure fn split_str(s: &'a str, sep: &'b str) -> ~[~str] {
     let mut result = ~[];
     do iter_between_matches(s, sep) |from, to| {
         unsafe { result.push(raw::slice_bytes(s, from, to)); }
@@ -583,7 +583,7 @@ pub pure fn split_str(s: &a/str, sep: &b/str) -> ~[~str] {
     result
 }
 
-pub pure fn split_str_nonempty(s: &a/str, sep: &b/str) -> ~[~str] {
+pub pure fn split_str_nonempty(s: &'a str, sep: &'b str) -> ~[~str] {
     let mut result = ~[];
     do iter_between_matches(s, sep) |from, to| {
         if to > from {
@@ -792,7 +792,7 @@ pure fn cmp(a: &str, b: &str) -> Ordering {
 
 #[cfg(notest)]
 impl TotalOrd for &'self str {
-    pure fn cmp(&self, other: & &self/str) -> Ordering { cmp(*self, *other) }
+    pure fn cmp(&self, other: & &'self str) -> Ordering { cmp(*self, *other) }
 }
 
 #[cfg(notest)]
@@ -837,13 +837,13 @@ pure fn gt(a: &str, b: &str) -> bool {
 }
 
 #[cfg(notest)]
-impl Eq for &self/str {
+impl Eq for &'self str {
     #[inline(always)]
-    pure fn eq(&self, other: & &self/str) -> bool {
+    pure fn eq(&self, other: & &'self str) -> bool {
         eq_slice((*self), (*other))
     }
     #[inline(always)]
-    pure fn ne(&self, other: & &self/str) -> bool { !(*self).eq(other) }
+    pure fn ne(&self, other: & &'self str) -> bool { !(*self).eq(other) }
 }
 
 #[cfg(notest)]
@@ -879,15 +879,15 @@ impl Ord for ~str {
 }
 
 #[cfg(notest)]
-impl Ord for &self/str {
+impl Ord for &'self str {
     #[inline(always)]
-    pure fn lt(&self, other: & &self/str) -> bool { lt((*self), (*other)) }
+    pure fn lt(&self, other: & &'self str) -> bool { lt((*self), (*other)) }
     #[inline(always)]
-    pure fn le(&self, other: & &self/str) -> bool { le((*self), (*other)) }
+    pure fn le(&self, other: & &'self str) -> bool { le((*self), (*other)) }
     #[inline(always)]
-    pure fn ge(&self, other: & &self/str) -> bool { ge((*self), (*other)) }
+    pure fn ge(&self, other: & &'self str) -> bool { ge((*self), (*other)) }
     #[inline(always)]
-    pure fn gt(&self, other: & &self/str) -> bool { gt((*self), (*other)) }
+    pure fn gt(&self, other: & &'self str) -> bool { gt((*self), (*other)) }
 }
 
 #[cfg(notest)]
@@ -1348,7 +1348,7 @@ pub pure fn rfind_between(s: &str, start: uint, end: uint,
 }
 
 // Utility used by various searching functions
-pure fn match_at(haystack: &a/str, needle: &b/str, at: uint) -> bool {
+pure fn match_at(haystack: &'a str, needle: &'b str, at: uint) -> bool {
     let mut i = at;
     for each(needle) |c| { if haystack[i] != c { return false; } i += 1u; }
     return true;
@@ -1367,7 +1367,7 @@ pure fn match_at(haystack: &a/str, needle: &b/str, at: uint) -> bool {
  * An `option` containing the byte index of the first matching substring
  * or `none` if there is no match
  */
-pub pure fn find_str(haystack: &a/str, needle: &b/str) -> Option<uint> {
+pub pure fn find_str(haystack: &'a str, needle: &'b str) -> Option<uint> {
     find_str_between(haystack, needle, 0u, len(haystack))
 }
 
@@ -1390,7 +1390,7 @@ pub pure fn find_str(haystack: &a/str, needle: &b/str) -> Option<uint> {
  *
  * `start` must be less than or equal to `len(s)`
  */
-pub pure fn find_str_from(haystack: &a/str, needle: &b/str, start: uint)
+pub pure fn find_str_from(haystack: &'a str, needle: &'b str, start: uint)
   -> Option<uint> {
     find_str_between(haystack, needle, start, len(haystack))
 }
@@ -1415,7 +1415,7 @@ pub pure fn find_str_from(haystack: &a/str, needle: &b/str, start: uint)
  * `start` must be less than or equal to `end` and `end` must be less than
  * or equal to `len(s)`.
  */
-pub pure fn find_str_between(haystack: &a/str, needle: &b/str, start: uint,
+pub pure fn find_str_between(haystack: &'a str, needle: &'b str, start: uint,
                          end:uint)
   -> Option<uint> {
     // See Issue #1932 for why this is a naive search
@@ -1441,7 +1441,7 @@ pub pure fn find_str_between(haystack: &a/str, needle: &b/str, start: uint,
  * * haystack - The string to look in
  * * needle - The string to look for
  */
-pub pure fn contains(haystack: &a/str, needle: &b/str) -> bool {
+pub pure fn contains(haystack: &'a str, needle: &'b str) -> bool {
     find_str(haystack, needle).is_some()
 }
 
@@ -1465,7 +1465,7 @@ pub pure fn contains_char(haystack: &str, needle: char) -> bool {
  * * haystack - The string to look in
  * * needle - The string to look for
  */
-pub pure fn starts_with(haystack: &a/str, needle: &b/str) -> bool {
+pub pure fn starts_with(haystack: &'a str, needle: &'b str) -> bool {
     let haystack_len = len(haystack), needle_len = len(needle);
     if needle_len == 0u { true }
     else if needle_len > haystack_len { false }
@@ -1480,7 +1480,7 @@ pub pure fn starts_with(haystack: &a/str, needle: &b/str) -> bool {
  * * haystack - The string to look in
  * * needle - The string to look for
  */
-pub pure fn ends_with(haystack: &a/str, needle: &b/str) -> bool {
+pub pure fn ends_with(haystack: &'a str, needle: &'b str) -> bool {
     let haystack_len = len(haystack), needle_len = len(needle);
     if needle_len == 0u { true }
     else if needle_len > haystack_len { false }
@@ -1662,7 +1662,7 @@ pub pure fn count_chars(s: &str, start: uint, end: uint) -> uint {
 }
 
 /// Counts the number of bytes taken by the `n` in `s` starting from `start`.
-pub pure fn count_bytes(s: &b/str, start: uint, n: uint) -> uint {
+pub pure fn count_bytes(s: &'b str, start: uint, n: uint) -> uint {
     fail_unless!(is_char_boundary(s, start));
     let mut end = start, cnt = n;
     let l = len(s);
@@ -1905,7 +1905,7 @@ pub pure fn as_bytes<T>(s: &const ~str, f: &fn(&~[u8]) -> T) -> T {
  *
  * The byte slice does not include the null terminator.
  */
-pub pure fn as_bytes_slice(s: &a/str) -> &a/[u8] {
+pub pure fn as_bytes_slice(s: &'a str) -> &'a [u8] {
     unsafe {
         let (ptr, len): (*u8, uint) = ::cast::reinterpret_cast(&s);
         let outgoing_tuple: (*u8, uint) = (ptr, len - 1);
@@ -2233,9 +2233,9 @@ pub mod traits {
     use ops::Add;
     use str::append;
 
-    impl Add<&self/str,~str> for ~str {
+    impl Add<&'self str,~str> for ~str {
         #[inline(always)]
-        pure fn add(&self, rhs: & &self/str) -> ~str {
+        pure fn add(&self, rhs: & &'self str) -> ~str {
             append(copy *self, (*rhs))
         }
     }
@@ -2247,7 +2247,7 @@ pub mod traits {}
 pub trait StrSlice {
     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(&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);
@@ -2261,8 +2261,8 @@ pub trait StrSlice {
     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 split_str(&self, sep: &'a str) -> ~[~str];
-    pure fn starts_with(&self, needle: &a/str) -> bool;
+    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;
@@ -2278,7 +2278,7 @@ pub trait StrSlice {
 }
 
 /// Extension methods for strings
-impl StrSlice for &self/str {
+impl StrSlice for &'self str {
     /**
      * Return true if a predicate matches all characters or if the string
      * contains no characters
@@ -2293,7 +2293,7 @@ impl StrSlice for &self/str {
     pure fn any(&self, it: &fn(char) -> bool) -> bool { any(*self, it) }
     /// Returns true if one string contains another
     #[inline]
-    pure fn contains(&self, needle: &a/str) -> bool {
+    pure fn contains(&self, needle: &'a str) -> bool {
         contains(*self, needle)
     }
     /// Returns true if a string contains a char
@@ -2366,10 +2366,10 @@ impl StrSlice for &self/str {
      * string
      */
     #[inline]
-    pure fn split_str(&self, 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(&self, needle: &a/str) -> bool {
+    pure fn starts_with(&self, needle: &'a str) -> bool {
         starts_with(*self, needle)
     }
     /**
@@ -2612,8 +2612,8 @@ mod tests {
 
     #[test]
     fn test_split_str() {
-        fn t(s: &str, sep: &a/str, i: int, k: &str) {
+        fn t(s: &str, sep: &'a str, i: int, k: &str) {
-            fn borrow(x: &a/str) -> &a/str { x }
+            fn borrow(x: &'a str) -> &'a str { x }
             let v = split_str(s, sep);
             fail_unless!(borrow(v[i]) == k);
         }

src/libcore/sys.rs

@@ -19,7 +19,7 @@ use libc::{c_void, c_char, size_t};
 use repr;
 use str;
 
-pub type FreeGlue = &self/fn(*TypeDesc, *c_void);
+pub type FreeGlue = &'self fn(*TypeDesc, *c_void);
 
 // Corresponds to runtime type_desc type
 pub struct TypeDesc {

src/libcore/task/local_data.rs

@@ -44,7 +44,7 @@ use task::rt;
  *
  * These two cases aside, the interface is safe.
  */
-pub type LocalDataKey<T> = &self/fn(v: @T);
+pub type LocalDataKey<T> = &'self fn(v: @T);
 
 /**
  * Remove a task-local data value from the table, returning the

src/libcore/task/spawn.rs

@@ -123,7 +123,7 @@ struct TaskGroupData {
 }
 type TaskGroupArc = unstable::Exclusive<Option<TaskGroupData>>;
 
-type TaskGroupInner = &self/mut Option<TaskGroupData>;
+type TaskGroupInner = &'self mut Option<TaskGroupData>;
 
 // A taskgroup is 'dead' when nothing can cause it to fail; only members can.
 pure fn taskgroup_is_dead(tg: &TaskGroupData) -> bool {

src/libcore/to_bytes.rs

@@ -19,7 +19,7 @@ use io::Writer;
 use option::{None, Option, Some};
 use str;
 
-pub type Cb = &self/fn(buf: &[const u8]) -> bool;
+pub type Cb = &'self fn(buf: &[const u8]) -> bool;
 
 /**
  * A trait to implement in order to make a type hashable;
@@ -197,7 +197,7 @@ impl IterBytes for int {
     }
 }
 
-impl<A:IterBytes> IterBytes for &self/[A] {
+impl<A:IterBytes> IterBytes for &'self [A] {
     #[inline(always)]
     pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
         for (*self).each |elt| {
@@ -231,7 +231,7 @@ impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
 }
 
 // Move this to vec, probably.
-pure fn borrow<A>(a: &x/[A]) -> &x/[A] {
+pure fn borrow<A>(a: &'x [A]) -> &'x [A] {
     a
 }
 
@@ -352,7 +352,7 @@ pub pure fn iter_bytes_7<A: IterBytes,
     g.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
 
-impl IterBytes for &self/str {
+impl IterBytes for &'self str {
     #[inline(always)]
     pure fn iter_bytes(&self, _lsb0: bool, f: Cb) {
         do str::byte_slice(*self) |bytes| {
@@ -389,7 +389,7 @@ impl<A:IterBytes> IterBytes for Option<A> {
     }
 }
 
-impl<A:IterBytes> IterBytes for &self/A {
+impl<A:IterBytes> IterBytes for &'self A {
     #[inline(always)]
     pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
         (**self).iter_bytes(lsb0, f);

src/libcore/to_str.rs

@@ -32,7 +32,7 @@ impl ToStr for ~str {
     #[inline(always)]
     pure fn to_str(&self) -> ~str { copy *self }
 }
-impl ToStr for &self/str {
+impl ToStr for &'self str {
     #[inline(always)]
     pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
 }
@@ -72,7 +72,7 @@ impl<A:ToStr,B:ToStr,C:ToStr> ToStr for (A, B, C) {
     }
 }
 
-impl<A:ToStr> ToStr for &self/[A] {
+impl<A:ToStr> ToStr for &'self [A] {
     #[inline(always)]
     pure fn to_str(&self) -> ~str {
         unsafe {

src/libcore/trie.rs

@@ -32,7 +32,7 @@ pub struct TrieMap<T> {
 impl<T> BaseIter<(uint, &'self T)> for TrieMap<T> {
     /// Visit all key-value pairs in order
     #[inline(always)]
-    pure fn each(&self, f: &fn(&(uint, &self/T)) -> bool) {
+    pure fn each(&self, f: &fn(&(uint, &'self T)) -> bool) {
         self.root.each(f);
     }
     #[inline(always)]
@@ -42,7 +42,7 @@ impl<T> BaseIter<(uint, &'self T)> for TrieMap<T> {
 impl<T> ReverseIter<(uint, &'self T)> for TrieMap<T> {
     /// Visit all key-value pairs in reverse order
     #[inline(always)]
-    pure fn each_reverse(&self, f: &fn(&(uint, &self/T)) -> bool) {
+    pure fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) {
         self.root.each_reverse(f);
     }
 }
@@ -93,8 +93,8 @@ impl<T> Map<uint, T> for TrieMap<T> {
 
     /// Return the value corresponding to the key in the map
     #[inline(hint)]
-    pure fn find(&self, key: &uint) -> Option<&self/T> {
+    pure fn find(&self, key: &uint) -> Option<&'self T> {
-        let mut node: &self/TrieNode<T> = &self.root;
+        let mut node: &'self TrieNode<T> = &self.root;
         let mut idx = 0;
         loop {
             match node.children[chunk(*key, idx)] {
@@ -233,7 +233,7 @@ impl<T> TrieNode<T> {
 }
 
 impl<T> TrieNode<T> {
-    pure fn each(&self, f: &fn(&(uint, &self/T)) -> bool) -> bool {
+    pure fn each(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool {
         for uint::range(0, self.children.len()) |idx| {
             match self.children[idx] {
                 Internal(ref x) => if !x.each(f) { return false },
@@ -244,7 +244,7 @@ impl<T> TrieNode<T> {
         true
     }
 
-    pure fn each_reverse(&self, f: &fn(&(uint, &self/T)) -> bool) -> bool {
+    pure fn each_reverse(&self, f: &fn(&(uint, &'self T)) -> bool) -> bool {
         for uint::range_rev(self.children.len(), 0) |idx| {
             match self.children[idx - 1] {
                 Internal(ref x) => if !x.each_reverse(f) { return false },

src/libcore/tuple.rs

@@ -47,19 +47,19 @@ impl<T:Copy,U:Copy> CopyableTuple<T, U> for (T, U) {
 }
 
 pub trait ImmutableTuple<T, U> {
-    pure fn first_ref(&self) -> &self/T;
+    pure fn first_ref(&self) -> &'self T;
-    pure fn second_ref(&self) -> &self/U;
+    pure fn second_ref(&self) -> &'self U;
 }
 
 impl<T, U> ImmutableTuple<T, U> for (T, U) {
     #[inline(always)]
-    pure fn first_ref(&self) -> &self/T {
+    pure fn first_ref(&self) -> &'self T {
         match *self {
             (ref t, _) => t,
         }
     }
     #[inline(always)]
-    pure fn second_ref(&self) -> &self/U {
+    pure fn second_ref(&self) -> &'self U {
         match *self {
             (_, ref u) => u,
         }
@@ -71,7 +71,7 @@ pub trait ExtendedTupleOps<A,B> {
     fn map<C>(&self, f: &fn(a: &A, b: &B) -> C) -> ~[C];
 }
 
-impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (&self/[A], &self/[B]) {
+impl<A:Copy,B:Copy> ExtendedTupleOps<A,B> for (&'self [A], &'self [B]) {
     #[inline(always)]
     fn zip(&self) -> ~[(A, B)] {
         match *self {

src/libcore/unstable.rs

@@ -173,7 +173,7 @@ pub unsafe fn get_shared_mutable_state<T:Owned>(
 }
 #[inline(always)]
 pub unsafe fn get_shared_immutable_state<T:Owned>(
-        rc: &a/SharedMutableState<T>) -> &a/T {
+        rc: &'a SharedMutableState<T>) -> &'a T {
     unsafe {
         let ptr: ~ArcData<T> = cast::reinterpret_cast(&(*rc).data);
         fail_unless!(ptr.count > 0);

src/libcore/unstable/finally.rs

@@ -31,7 +31,7 @@ pub trait Finally<T> {
     fn finally(&self, dtor: &fn()) -> T;
 }
 
-impl<T> Finally<T> for &self/fn() -> T {
+impl<T> Finally<T> for &'self fn() -> T {
     fn finally(&self, dtor: &fn()) -> T {
         let _d = Finallyalizer {
             dtor: dtor
@@ -42,7 +42,7 @@ impl<T> Finally<T> for &self/fn() -> T {
 }
 
 struct Finallyalizer {
-    dtor: &self/fn()
+    dtor: &'self fn()
 }
 
 impl Drop for Finallyalizer/&self {

src/libcore/unstable/global.rs

@@ -42,7 +42,7 @@ use sys::Closure;
 #[cfg(test)] use task::spawn;
 #[cfg(test)] use uint;
 
-pub type GlobalDataKey<T> = &self/fn(v: T);
+pub type GlobalDataKey<T> = &'self fn(v: T);
 
 pub unsafe fn global_data_clone_create<T:Owned + Clone>(
     key: GlobalDataKey<T>, create: &fn() -> ~T) -> T {

src/libcore/vec.rs

@@ -217,46 +217,46 @@ pub pure fn build_sized_opt<A>(size: Option<uint>,
 // Accessors
 
 /// Returns the first element of a vector
-pub pure fn head<T>(v: &r/[T]) -> &r/T {
+pub pure fn head<T>(v: &'r [T]) -> &'r T {
     if v.len() == 0 { fail!(~"head: empty vector") }
     &v[0]
 }
 
 /// Returns `Some(x)` where `x` is the first element of the slice `v`,
 /// or `None` if the vector is empty.
-pub pure fn head_opt<T>(v: &r/[T]) -> Option<&r/T> {
+pub pure fn head_opt<T>(v: &'r [T]) -> Option<&'r T> {
     if v.len() == 0 { None } else { Some(&v[0]) }
 }
 
 /// Returns a vector containing all but the first element of a slice
-pub pure fn tail<T>(v: &r/[T]) -> &r/[T] { slice(v, 1, v.len()) }
+pub pure fn tail<T>(v: &'r [T]) -> &'r [T] { slice(v, 1, v.len()) }
 
 /// Returns a vector containing all but the first `n` elements of a slice
-pub pure fn tailn<T>(v: &r/[T], n: uint) -> &r/[T] { slice(v, n, v.len()) }
+pub pure fn tailn<T>(v: &'r [T], n: uint) -> &'r [T] { slice(v, n, v.len()) }
 
 /// Returns a vector containing all but the last element of a slice
-pub pure fn init<T>(v: &r/[T]) -> &r/[T] { slice(v, 0, v.len() - 1) }
+pub pure fn init<T>(v: &'r [T]) -> &'r [T] { slice(v, 0, v.len() - 1) }
 
 /// Returns a vector containing all but the last `n' elements of a slice
-pub pure fn initn<T>(v: &r/[T], n: uint) -> &r/[T] {
+pub pure fn initn<T>(v: &'r [T], n: uint) -> &'r [T] {
     slice(v, 0, v.len() - n)
 }
 
 /// Returns the last element of the slice `v`, failing if the slice is empty.
-pub pure fn last<T>(v: &r/[T]) -> &r/T {
+pub pure fn last<T>(v: &'r [T]) -> &'r T {
     if v.len() == 0 { fail!(~"last: empty vector") }
     &v[v.len() - 1]
 }
 
 /// Returns `Some(x)` where `x` is the last element of the slice `v`, or
 /// `None` if the vector is empty.
-pub pure fn last_opt<T>(v: &r/[T]) -> Option<&r/T> {
+pub pure fn last_opt<T>(v: &'r [T]) -> Option<&'r T> {
     if v.len() == 0 { None } else { Some(&v[v.len() - 1]) }
 }
 
 /// Return a slice that points into another slice.
 #[inline(always)]
-pub pure fn slice<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
+pub pure fn slice<T>(v: &'r [T], start: uint, end: uint) -> &'r [T] {
     fail_unless!(start <= end);
     fail_unless!(end <= len(v));
     do as_imm_buf(v) |p, _len| {
@@ -270,10 +270,10 @@ pub pure fn slice<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
 
 /// Return a slice that points into another slice.
 #[inline(always)]
-pub pure fn mut_slice<T>(v: &r/mut [T],
+pub pure fn mut_slice<T>(v: &'r mut [T],
                          start: uint,
                          end: uint)
-                      -> &r/mut [T] {
+                      -> &'r mut [T] {
     fail_unless!(start <= end);
     fail_unless!(end <= v.len());
     do as_mut_buf(v) |p, _len| {
@@ -287,10 +287,10 @@ pub pure fn mut_slice<T>(v: &r/mut [T],
 
 /// Return a slice that points into another slice.
 #[inline(always)]
-pub pure fn const_slice<T>(v: &r/[const T],
+pub pure fn const_slice<T>(v: &'r [const T],
                            start: uint,
                            end: uint)
-                        -> &r/[const T] {
+                        -> &'r [const T] {
     fail_unless!(start <= end);
     fail_unless!(end <= len(v));
     do as_const_buf(v) |p, _len| {
@@ -1334,7 +1334,7 @@ pub pure fn reversed<T:Copy>(v: &[const T]) -> ~[T] {
  * ~~~
  */
 #[inline(always)]
-pub pure fn each<T>(v: &r/[T], f: &fn(&r/T) -> bool) {
+pub pure fn each<T>(v: &'r [T], f: &fn(&'r T) -> bool) {
     //             ^^^^
     // NB---this CANNOT be &[const T]!  The reason
     // is that you are passing it to `f()` using
@@ -1389,7 +1389,7 @@ pub pure fn each_const<T>(v: &[const T], f: &fn(elem: &const T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn eachi<T>(v: &r/[T], f: &fn(uint, v: &r/T) -> bool) {
+pub pure fn eachi<T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) {
     let mut i = 0;
     for each(v) |p| {
         if !f(i, p) { return; }
@@ -1403,7 +1403,7 @@ pub pure fn eachi<T>(v: &r/[T], f: &fn(uint, v: &r/T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn rev_each<T>(v: &r/[T], blk: &fn(v: &r/T) -> bool) {
+pub pure fn rev_each<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
     rev_eachi(v, |_i, v| blk(v))
 }
 
@@ -1413,7 +1413,7 @@ pub pure fn rev_each<T>(v: &r/[T], blk: &fn(v: &r/T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn rev_eachi<T>(v: &r/[T], blk: &fn(i: uint, v: &r/T) -> bool) {
+pub pure fn rev_eachi<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
     let mut i = v.len();
     while i > 0 {
         i -= 1;
@@ -1555,11 +1555,11 @@ pure fn eq<T:Eq>(a: &[T], b: &[T]) -> bool {
 }
 
 #[cfg(notest)]
-impl<T:Eq> Eq for &self/[T] {
+impl<T:Eq> Eq for &'self [T] {
     #[inline(always)]
-    pure fn eq(&self, other: & &self/[T]) -> bool { eq((*self), (*other)) }
+    pure fn eq(&self, other: & &'self [T]) -> bool { eq((*self), (*other)) }
     #[inline(always)]
-    pure fn ne(&self, other: & &self/[T]) -> bool { !(*self).eq(other) }
+    pure fn ne(&self, other: & &'self [T]) -> bool { !(*self).eq(other) }
 }
 
 
@@ -1604,7 +1604,7 @@ pure fn cmp<T: TotalOrd>(a: &[T], b: &[T]) -> Ordering {
 #[cfg(notest)]
 impl<T: TotalOrd> TotalOrd for &'self [T] {
     #[inline(always)]
-    pure fn cmp(&self, other: & &self/[T]) -> Ordering { cmp(*self, *other) }
+    pure fn cmp(&self, other: & &'self [T]) -> Ordering { cmp(*self, *other) }
 }
 
 #[cfg(notest)]
@@ -1639,15 +1639,15 @@ pure fn ge<T:Ord>(a: &[T], b: &[T]) -> bool { !lt(a, b) }
 pure fn gt<T:Ord>(a: &[T], b: &[T]) -> bool { lt(b, a)  }
 
 #[cfg(notest)]
-impl<T:Ord> Ord for &self/[T] {
+impl<T:Ord> Ord for &'self [T] {
     #[inline(always)]
-    pure fn lt(&self, other: & &self/[T]) -> bool { lt((*self), (*other)) }
+    pure fn lt(&self, other: & &'self [T]) -> bool { lt((*self), (*other)) }
     #[inline(always)]
-    pure fn le(&self, other: & &self/[T]) -> bool { le((*self), (*other)) }
+    pure fn le(&self, other: & &'self [T]) -> bool { le((*self), (*other)) }
     #[inline(always)]
-    pure fn ge(&self, other: & &self/[T]) -> bool { ge((*self), (*other)) }
+    pure fn ge(&self, other: & &'self [T]) -> bool { ge((*self), (*other)) }
     #[inline(always)]
-    pure fn gt(&self, other: & &self/[T]) -> bool { gt((*self), (*other)) }
+    pure fn gt(&self, other: & &'self [T]) -> bool { gt((*self), (*other)) }
 }
 
 #[cfg(notest)]
@@ -1680,15 +1680,15 @@ pub mod traits {
     use ops::Add;
     use vec::append;
 
-    impl<T:Copy> Add<&self/[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] {
+        pure fn add(&self, rhs: & &'self [const T]) -> ~[T] {
             append(copy *self, (*rhs))
         }
     }
 }
 
-impl<T> Container for &self/[const T] {
+impl<T> Container for &'self [const T] {
     /// Returns true if a vector contains no elements
     #[inline]
     pure fn is_empty(&self) -> bool { is_empty(*self) }
@@ -1712,15 +1712,15 @@ impl<T: Copy> CopyableVector<T> for &'self [const T] {
 }
 
 pub trait ImmutableVector<T> {
-    pure fn view(&self, start: uint, end: uint) -> &self/[T];
+    pure fn view(&self, start: uint, end: uint) -> &'self [T];
-    pure fn head(&self) -> &self/T;
+    pure fn head(&self) -> &'self T;
-    pure fn head_opt(&self) -> Option<&self/T>;
+    pure fn head_opt(&self) -> Option<&'self T>;
-    pure fn tail(&self) -> &self/[T];
+    pure fn tail(&self) -> &'self [T];
-    pure fn tailn(&self, n: uint) -> &self/[T];
+    pure fn tailn(&self, n: uint) -> &'self [T];
-    pure fn init(&self) -> &self/[T];
+    pure fn init(&self) -> &'self [T];
-    pure fn initn(&self, n: uint) -> &self/[T];
+    pure fn initn(&self, n: uint) -> &'self [T];
-    pure fn last(&self) -> &self/T;
+    pure fn last(&self) -> &'self T;
-    pure fn last_opt(&self) -> Option<&self/T>;
+    pure fn last_opt(&self) -> Option<&'self T>;
     pure fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U;
     pure fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
     pure fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
@@ -1731,44 +1731,44 @@ pub trait ImmutableVector<T> {
 }
 
 /// Extension methods for vectors
-impl<T> ImmutableVector<T> for &self/[T] {
+impl<T> ImmutableVector<T> for &'self [T] {
     /// Return a slice that points into another slice.
     #[inline]
-    pure fn view(&self, start: uint, end: uint) -> &self/[T] {
+    pure fn view(&self, start: uint, end: uint) -> &'self [T] {
         slice(*self, start, end)
     }
 
     /// Returns the first element of a vector, failing if the vector is empty.
     #[inline]
-    pure fn head(&self) -> &self/T { head(*self) }
+    pure fn head(&self) -> &'self T { head(*self) }
 
     /// Returns the first element of a vector
     #[inline]
-    pure fn head_opt(&self) -> Option<&self/T> { head_opt(*self) }
+    pure fn head_opt(&self) -> Option<&'self T> { head_opt(*self) }
 
     /// Returns all but the first element of a vector
     #[inline]
-    pure fn tail(&self) -> &self/[T] { tail(*self) }
+    pure fn tail(&self) -> &'self [T] { tail(*self) }
 
     /// Returns all but the first `n' elements of a vector
     #[inline]
-    pure fn tailn(&self, n: uint) -> &self/[T] { tailn(*self, n) }
+    pure fn tailn(&self, n: uint) -> &'self [T] { tailn(*self, n) }
 
     /// Returns all but the last elemnt of a vector
     #[inline]
-    pure fn init(&self) -> &self/[T] { init(*self) }
+    pure fn init(&self) -> &'self [T] { init(*self) }
 
     /// Returns all but the last `n' elemnts of a vector
     #[inline]
-    pure fn initn(&self, n: uint) -> &self/[T] { initn(*self, n) }
+    pure fn initn(&self, n: uint) -> &'self [T] { initn(*self, n) }
 
     /// Returns the last element of a `v`, failing if the vector is empty.
     #[inline]
-    pure fn last(&self) -> &self/T { last(*self) }
+    pure fn last(&self) -> &'self T { last(*self) }
 
     /// Returns the last element of a `v`, failing if the vector is empty.
     #[inline]
-    pure fn last_opt(&self) -> Option<&self/T> { last_opt(*self) }
+    pure fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
 
     /// Reduce a vector from right to left
     #[inline]
@@ -1834,7 +1834,7 @@ pub trait ImmutableEqVector<T:Eq> {
     pure fn rposition_elem(&self, t: &T) -> Option<uint>;
 }
 
-impl<T:Eq> ImmutableEqVector<T> for &self/[T] {
+impl<T:Eq> ImmutableEqVector<T> for &'self [T] {
     /**
      * Find the first index matching some predicate
      *
@@ -1879,7 +1879,7 @@ pub trait ImmutableCopyableVector<T> {
 }
 
 /// Extension methods for vectors
-impl<T:Copy> ImmutableCopyableVector<T> for &self/[T] {
+impl<T:Copy> ImmutableCopyableVector<T> for &'self [T] {
     /**
      * Construct a new vector from the elements of a vector for which some
      * predicate holds.
@@ -2139,7 +2139,7 @@ pub mod raw {
                                     len: uint,
                                     f: &fn(v: &[T]) -> U) -> U {
         let pair = (p, len * sys::nonzero_size_of::<T>());
-        let v : *(&blk/[T]) =
+        let v : *(&'blk [T]) =
             ::cast::reinterpret_cast(&addr_of(&pair));
         f(*v)
     }
@@ -2153,7 +2153,7 @@ pub mod raw {
                                         len: uint,
                                         f: &fn(v: &mut [T]) -> U) -> U {
         let pair = (p, len * sys::nonzero_size_of::<T>());
-        let v : *(&blk/mut [T]) =
+        let v : *(&'blk mut [T]) =
             ::cast::reinterpret_cast(&addr_of(&pair));
         f(*v)
     }
@@ -2327,7 +2327,7 @@ impl<A> iter::MutableIter<A> for @mut [A] {
     }
 }
 
-impl<A> iter::ExtendedIter<A> for &self/[A] {
+impl<A> iter::ExtendedIter<A> for &'self [A] {
     pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
         iter::eachi(self, blk)
     }
@@ -2404,7 +2404,7 @@ impl<A> iter::ExtendedIter<A> for @[A] {
     }
 }
 
-impl<A:Eq> iter::EqIter<A> for &self/[A] {
+impl<A:Eq> iter::EqIter<A> for &'self [A] {
     pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
     pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
 }
@@ -2421,7 +2421,7 @@ impl<A:Eq> iter::EqIter<A> for @[A] {
     pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
 }
 
-impl<A:Copy> iter::CopyableIter<A> for &self/[A] {
+impl<A:Copy> iter::CopyableIter<A> for &'self [A] {
     pure fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] {
         iter::filter_to_vec(self, pred)
     }
@@ -2453,7 +2453,7 @@ impl<A:Copy> iter::CopyableIter<A> for @[A] {
     }
 }
 
-impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for &self/[A] {
+impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for &'self [A] {
     pure fn min(&self) -> A { iter::min(self) }
     pure fn max(&self) -> A { iter::max(self) }
 }
@@ -2470,7 +2470,7 @@ impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for @[A] {
     pure fn max(&self) -> A { iter::max(self) }
 }
 
-impl<A:Copy> iter::CopyableNonstrictIter<A> for &self/[A] {
+impl<A:Copy> iter::CopyableNonstrictIter<A> for &'self [A] {
     pure fn each_val(&const self, f: &fn(A) -> bool) {
         let mut i = 0;
         while i < self.len() {

src/librust/rust.rc

@@ -38,23 +38,23 @@ impl ValidUsage {
 }
 
 enum Action {
-    Exec(&self/str),
+    Exec(&'self str),
-    Call(&self/fn(args: &[~str]) -> ValidUsage)
+    Call(&'self fn(args: &[~str]) -> ValidUsage)
 }
 
 enum UsageSource {
-    UsgExec(&self/str),
+    UsgExec(&'self str),
-    UsgStr(&self/str)
+    UsgStr(&'self str)
 }
 
 struct Command {
-    cmd: &self/str,
+    cmd: &'self str,
     action: Action/&self,
-    usage_line: &self/str,
+    usage_line: &'self str,
     usage_full: UsageSource/&self
 }
 
-const commands: &static/[Command/&static] = &[
+const commands: &'static [Command/&static] = &[
     Command{
         cmd: "build",
         action: Exec("rustc"),

src/librustc/front/core_inject.rs

@@ -19,7 +19,7 @@ use syntax::codemap;
 use syntax::codemap::dummy_sp;
 use syntax::fold;
 
-const CORE_VERSION: &static/str = "0.6";
+const CORE_VERSION: &'static str = "0.6";
 
 pub fn maybe_inject_libcore_ref(sess: Session,
                                 crate: @ast::crate) -> @ast::crate {

src/librustc/front/test.rs

@@ -257,7 +257,7 @@ mod __test {
     std::test::test_main_static(::os::args(), tests)
   }
 
-  const tests : &static/[std::test::TestDescAndFn] = &[
+  const tests : &'static [std::test::TestDescAndFn] = &[
     ... the list of tests in the crate ...
   ];
 }
@@ -352,7 +352,7 @@ fn path_node_global(+ids: ~[ast::ident]) -> @ast::path {
                  types: ~[] }
 }
 
-
+#[cfg(stage0)]
 fn mk_tests(cx: &TestCtxt) -> @ast::item {
 
     let ext_cx = cx.ext_cx;
@@ -367,6 +367,22 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
     )).get()
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+fn mk_tests(cx: &TestCtxt) -> @ast::item {
+
+    let ext_cx = cx.ext_cx;
+
+    // The vector of test_descs for this crate
+    let test_descs = mk_test_descs(cx);
+
+    (quote_item!(
+        pub const tests : &'static [self::std::test::TestDescAndFn] =
+            $test_descs
+        ;
+    )).get()
+}
+
 fn is_std(cx: &TestCtxt) -> bool {
     let is_std = {
         let items = attr::find_linkage_metas(cx.crate.node.attrs);

src/librustc/metadata/decoder.rs

@@ -66,7 +66,7 @@ fn lookup_hash(d: ebml::Doc, eq_fn: &fn(x:&[u8]) -> bool, hash: uint) ->
     None
 }
 
-pub type GetCrateDataCb = &self/fn(ast::crate_num) -> cmd;
+pub type GetCrateDataCb = &'self fn(ast::crate_num) -> cmd;
 
 pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
     fn eq_item(bytes: &[u8], item_id: int) -> bool {
@@ -544,7 +544,7 @@ pub fn get_item_path(intr: @ident_interner, cdata: cmd, id: ast::node_id)
     item_path(intr, lookup_item(id, cdata.data))
 }
 
-pub type decode_inlined_item = &self/fn(
+pub type decode_inlined_item = &'self fn(
     cdata: @cstore::crate_metadata,
     tcx: ty::ctxt,
     path: ast_map::path,

src/librustc/metadata/encoder.rs

@@ -1291,7 +1291,7 @@ fn encode_hash(ebml_w: writer::Encoder, hash: &str) {
 }
 
 // NB: Increment this as you change the metadata encoding version.
-pub const metadata_encoding_version : &static/[u8] =
+pub const metadata_encoding_version : &'static [u8] =
     &[0x72, //'r' as u8,
       0x75, //'u' as u8,
       0x73, //'s' as u8,

src/librustc/metadata/filesearch.rs

@@ -21,7 +21,7 @@ use core::result::Result;
 use core::result;
 use core::str;
 
-pub type pick<T> = &self/fn(path: &Path) -> Option<T>;
+pub type pick<T> = &'self fn(path: &Path) -> Option<T>;
 
 pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
     if path.file_path() == file { option::Some(copy *path) }

src/librustc/metadata/tydecode.rs

@@ -49,7 +49,7 @@ pub enum DefIdSource {
     // Identifies a type parameter (`fn foo<X>() { ... }`).
     TypeParameter
 }
-type conv_did = &self/fn(source: DefIdSource, ast::def_id) -> ast::def_id;
+type conv_did = &'self fn(source: DefIdSource, ast::def_id) -> ast::def_id;
 
 pub struct PState {
     data: @~[u8],

src/librustc/middle/borrowck/gather_loans.rs

@@ -514,7 +514,7 @@ pub impl GatherLoanCtxt {
         // consumes one mut pointer and returns a narrower one:
         //
         //     struct Foo { f: int }
-        //     fn foo(p: &v/mut Foo) -> &v/mut int { &mut p.f }
+        //     fn foo(p: &'v mut Foo) -> &'v mut int { &mut p.f }
         //
         // I think this should work fine but there is more subtlety to it than
         // I at first imagined. Unfortunately it's a very important use case,

src/librustc/middle/borrowck/preserve.rs

@@ -64,7 +64,7 @@ pub impl BorrowckCtxt {
 }
 
 struct PreserveCtxt {
-    bccx: &self/BorrowckCtxt,
+    bccx: &'self BorrowckCtxt,
 
     // the region scope for which we must preserve the memory
     scope_region: ty::Region,

src/librustc/middle/kind.rs

@@ -55,7 +55,7 @@ use syntax::{visit, ast_util};
 // primitives in the stdlib are explicitly annotated to only take sendable
 // types.
 
-pub const try_adding: &static/str = "Try adding a move";
+pub const try_adding: &'static str = "Try adding a move";
 
 pub type rval_map = HashMap<node_id, ()>;
 

src/librustc/middle/lang_items.rs

@@ -96,7 +96,7 @@ pub impl LanguageItems {
         }
     }
 
-    static pub fn item_name(&self, index: uint) -> &static/str {
+    static pub fn item_name(&self, index: uint) -> &'static str {
         match index {
             0  => "const",
             1  => "copy",
@@ -257,7 +257,7 @@ pub impl LanguageItems {
 
 fn LanguageItemCollector(crate: @crate,
                          session: Session,
-                         items: &r/mut LanguageItems)
+                         items: &'r mut LanguageItems)
                       -> LanguageItemCollector/&r {
     let item_refs = HashMap();
 
@@ -312,7 +312,7 @@ fn LanguageItemCollector(crate: @crate,
 }
 
 struct LanguageItemCollector {
-    items: &self/mut LanguageItems,
+    items: &'self mut LanguageItems,
 
     crate: @crate,
     session: Session,

src/librustc/middle/lint.rs

@@ -90,7 +90,7 @@ pub enum lint {
     // dead_assignment
 }
 
-pub fn level_to_str(lv: level) -> &static/str {
+pub fn level_to_str(lv: level) -> &'static str {
     match lv {
       allow => "allow",
       warn => "warn",
@@ -106,7 +106,7 @@ pub enum level {
 
 struct LintSpec {
     lint: lint,
-    desc: &static/str,
+    desc: &'static str,
     default: level
 }
 
@@ -881,14 +881,14 @@ fn check_item_non_camel_case_types(cx: ty::ctxt, it: @ast::item) {
             !ident.contains_char('_')
     }
 
-    fn ident_without_trailing_underscores(ident: &r/str) -> &r/str {
+    fn ident_without_trailing_underscores(ident: &'r str) -> &'r str {
         match str::rfind(ident, |c| c != '_') {
             Some(idx) => str::view(ident, 0, idx + 1),
             None => ident, // all underscores
         }
     }
 
-    fn ident_without_leading_underscores(ident: &r/str) -> &r/str {
+    fn ident_without_leading_underscores(ident: &'r str) -> &'r str {
         match str::find(ident, |c| c != '_') {
             Some(idx) => str::view(ident, idx, ident.len()),
             None => ident // all underscores

src/librustc/middle/region.rs

@@ -438,7 +438,7 @@ pub fn join_variance(++variance1: region_variance,
 /// particular site to yield the final variance of the reference.
 ///
 /// Example: if we are checking function arguments then the ambient
-/// variance is contravariant.  If we then find a `&r/T` pointer, `r`
+/// variance is contravariant.  If we then find a `&'r T` pointer, `r`
 /// appears in a co-variant position.  This implies that this
 /// occurrence of `r` is contra-variant with respect to the current
 /// item, and hence the function returns `rv_contravariant`.
@@ -517,9 +517,9 @@ pub impl DetermineRpCtxt {
     // concrete.
     //
     // 1. impl foo for &int { ... }
-    // 2. impl foo for &self/int { ... }
+    // 2. impl foo for &'self int { ... }
-    // 3. impl foo for bar { fn m(@self) -> &self/int { ... } }
+    // 3. impl foo for bar { fn m(@self) -> &'self int { ... } }
-    // 4. impl foo for bar { fn m(&self) -> &self/int { ... } }
+    // 4. impl foo for bar { fn m(&self) -> &'self int { ... } }
     // 5. impl foo for bar { fn m(&self) -> &int { ... } }
     //
     // In case 1, the anonymous region is being referenced,
@@ -644,9 +644,9 @@ pub fn determine_rp_in_ty(ty: @ast::Ty,
     // impl etc.  So we can ignore it and its components.
     if cx.item_id == 0 { return; }
 
-    // if this type directly references a region pointer like &r/ty,
+    // if this type directly references a region pointer like &'r ty,
-    // add to the worklist/set.  Note that &r/ty is contravariant with
+    // add to the worklist/set.  Note that &'r ty is contravariant with
-    // respect to &r, because &r/ty can be used whereever a *smaller*
+    // respect to &r, because &'r ty can be used whereever a *smaller*
     // region is expected (and hence is a supertype of those
     // locations)
     let sess = cx.sess;

src/librustc/middle/resolve.rs

@@ -212,7 +212,7 @@ pub impl<T> ResolveResult<T> {
 
 pub enum TypeParameters/& {
     NoTypeParameters,                  //< No type parameters.
-    HasTypeParameters(&self/Generics,  //< Type parameters.
+    HasTypeParameters(&'self Generics,  //< Type parameters.
                       node_id,         //< ID of the enclosing item
 
                       // The index to start numbering the type parameters at.

src/librustc/middle/trans/_match.rs

@@ -327,7 +327,7 @@ pub type BindingsMap = HashMap<ident, BindingInfo>;
 
 pub struct ArmData {
     bodycx: block,
-    arm: &self/ast::arm,
+    arm: &'self ast::arm,
     bindings_map: BindingsMap
 }
 
@@ -391,7 +391,7 @@ pub fn expand_nested_bindings(bcx: block, m: &[@Match/&r],
     }
 }
 
-pub type enter_pat = &self/fn(@ast::pat) -> Option<~[@ast::pat]>;
+pub type enter_pat = &'self fn(@ast::pat) -> Option<~[@ast::pat]>;
 
 pub fn assert_is_binding_or_wild(bcx: block, p: @ast::pat) {
     if !pat_is_binding_or_wild(bcx.tcx().def_map, p) {

src/librustc/middle/trans/callee.rs

@@ -550,8 +550,8 @@ pub fn trans_call_inner(
 
 
 pub enum CallArgs {
-    ArgExprs(&self/[@ast::expr]),
+    ArgExprs(&'self [@ast::expr]),
-    ArgVals(&self/[ValueRef])
+    ArgVals(&'self [ValueRef])
 }
 
 pub struct Args {

src/librustc/middle/trans/datum.rs

@@ -617,7 +617,7 @@ pub impl Datum {
         // using `to_ref_llval()`).
 
         // Convert to ref, yielding lltype *T.  Then create a Rust
-        // type &static/T (which translates to *T).  Construct new
+        // type &'static T (which translates to *T).  Construct new
         // result (which will be by-value).  Note that it is not
         // significant *which* region we pick here.
         let llval = self.to_ref_llval(bcx);

src/librustc/middle/trans/tvec.rs

@@ -520,7 +520,7 @@ pub fn get_base_and_len(bcx: block,
 
 pub type val_and_ty_fn = @fn(block, ValueRef, ty::t) -> Result;
 
-pub type iter_vec_block = &self/fn(block, ValueRef, ty::t) -> block;
+pub type iter_vec_block = &'self fn(block, ValueRef, ty::t) -> block;
 
 pub fn iter_vec_raw(bcx: block, data_ptr: ValueRef, vec_ty: ty::t,
                     fill: ValueRef, f: iter_vec_block) -> block {

src/librustc/middle/ty.rs

@@ -448,13 +448,13 @@ pub enum Region {
 #[auto_encode]
 #[auto_decode]
 pub enum bound_region {
-    /// The self region for structs, impls (&T in a type defn or &self/T)
+    /// The self region for structs, impls (&T in a type defn or &'self T)
     br_self,
 
     /// An anonymous region parameter for a given fn (&T)
     br_anon(uint),
 
-    /// Named region parameters for functions (a in &a/T)
+    /// Named region parameters for functions (a in &'a T)
     br_named(ast::ident),
 
     /// Fresh bound identifiers created during GLB computations.

src/librustc/middle/typeck/astconv.rs

@@ -46,7 +46,7 @@
  *   type foo/& = ...;
  *   type bar = fn(&foo, &a.foo)
  * The fully expanded version of type bar is:
- *   type bar = fn(&foo/&, &a.foo/&a)
+ *   type bar = fn(&'foo &, &a.foo/&a)
  * Note that the self region for the `foo` defaulted to `&` in the first
  * case but `&a` in the second.  Basically, defaults that appear inside
  * an rptr (`&r.T`) use the region `r` that appears in the rptr.

src/librustc/middle/typeck/check/method.rs

@@ -157,7 +157,7 @@ pub struct LookupContext {
     self_expr: @ast::expr,
     callee_id: node_id,
     m_name: ast::ident,
-    supplied_tps: &self/[ty::t],
+    supplied_tps: &'self [ty::t],
     impl_dups: HashMap<def_id, ()>,
     inherent_candidates: @mut ~[Candidate],
     extension_candidates: @mut ~[Candidate],

src/librustc/middle/typeck/check/regionck.rs

@@ -18,7 +18,7 @@ know whether a given type will be a region pointer or not until this
 phase.
 
 In particular, we ensure that, if the type of an expression or
-variable is `&r/T`, then the expression or variable must occur within
+variable is `&'r T`, then the expression or variable must occur within
 the region scope `r`.  Note that in some cases `r` may still be a
 region variable, so this gives us a chance to influence the value for
 `r` that we infer to ensure we choose a value large enough to enclose
@@ -500,7 +500,7 @@ pub mod guarantor {
      *
      *     struct Foo { i: int }
      *     struct Bar { foo: Foo  }
-     *     fn get_i(x: &a/Bar) -> &a/int {
+     *     fn get_i(x: &'a Bar) -> &'a int {
      *        let foo = &x.foo; // Lifetime L1
      *        &foo.i            // Lifetime L2
      *     }

src/librustc/middle/typeck/coherence.rs

@@ -550,8 +550,8 @@ pub impl CoherenceChecker {
     }
 
     fn can_unify_universally_quantified(&self,
-                                        a: &a/UniversalQuantificationResult,
+                                        a: &'a UniversalQuantificationResult,
-                                        b: &a/UniversalQuantificationResult)
+                                        b: &'a UniversalQuantificationResult)
                                      -> bool {
         let mut might_unify = true;
         let _ = do self.inference_context.probe {

src/librustc/middle/typeck/collect.rs

@@ -438,7 +438,7 @@ pub fn compare_impl_method(tcx: ty::ctxt,
 
     // Replace any references to the self region in the self type with
     // a free region.  So, for example, if the impl type is
-    // "&self/str", then this would replace the self type with a free
+    // "&'self str", then this would replace the self type with a free
     // region `self`.
     let dummy_self_r = ty::re_free(cm.body_id, ty::br_self);
     let self_ty = replace_bound_self(tcx, self_ty, dummy_self_r);
@@ -601,7 +601,7 @@ pub fn convert_methods(ccx: &CrateCtxt,
 pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt,
                                  span: span,
                                  generics: &ast::Generics,
-                                 thing: &static/str) {
+                                 thing: &'static str) {
     for generics.ty_params.each |ty_param| {
         if ty_param.bounds.len() > 0 {
             ccx.tcx.sess.span_err(

src/librustc/middle/typeck/infer/lattice.rs

@@ -58,7 +58,7 @@ pub trait LatticeValue {
                  -> cres<Self>;
 }
 
-pub type LatticeOp<T> = &self/fn(cf: &CombineFields, a: &T, b: &T) -> cres<T>;
+pub type LatticeOp<T> = &'self fn(cf: &CombineFields, a: &T, b: &T) -> cres<T>;
 
 impl LatticeValue for ty::t {
     static fn sub(&self, cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures {
@@ -378,7 +378,7 @@ pub fn super_lattice_tys<L:LatticeDir + TyLatticeDir + Combine>(
     }
 }
 
-pub type LatticeDirOp<T> = &self/fn(a: &T, b: &T) -> cres<T>;
+pub type LatticeDirOp<T> = &'self fn(a: &T, b: &T) -> cres<T>;
 
 pub enum LatticeVarResult<V,T> {
     VarResult(V),

src/librustc/middle/typeck/infer/region_inference.rs

@@ -153,7 +153,7 @@ The problem we are addressing is that there is a kind of subtyping
 between functions with bound region parameters.  Consider, for
 example, whether the following relation holds:
 
-    fn(&a/int) <: &fn(&b/int)? (Yes, a => b)
+    fn(&'a int) <: &fn(&'b int)? (Yes, a => b)
 
 The answer is that of course it does.  These two types are basically
 the same, except that in one we used the name `a` and one we used
@@ -163,14 +163,14 @@ In the examples that follow, it becomes very important to know whether
 a lifetime is bound in a function type (that is, is a lifetime
 parameter) or appears free (is defined in some outer scope).
 Therefore, from now on I will write the bindings explicitly, using a
-notation like `fn<a>(&a/int)` to indicate that `a` is a lifetime
+notation like `fn<a>(&'a int)` to indicate that `a` is a lifetime
 parameter.
 
 Now let's consider two more function types.  Here, we assume that the
 `self` lifetime is defined somewhere outside and hence is not a
 lifetime parameter bound by the function type (it "appears free"):
 
-    fn<a>(&a/int) <: &fn(&self/int)? (Yes, a => self)
+    fn<a>(&'a int) <: &fn(&'self int)? (Yes, a => self)
 
 This subtyping relation does in fact hold.  To see why, you have to
 consider what subtyping means.  One way to look at `T1 <: T2` is to
@@ -187,7 +187,7 @@ to the same thing: a function that accepts pointers with any lifetime
 
 So, what if we reverse the order of the two function types, like this:
 
-    fn(&self/int) <: &fn<a>(&a/int)? (No)
+    fn(&'self int) <: &fn<a>(&'a int)? (No)
 
 Does the subtyping relationship still hold?  The answer of course is
 no.  In this case, the function accepts *only the lifetime `&self`*,
@@ -196,8 +196,8 @@ accepted any lifetime.
 
 What about these two examples:
 
-    fn<a,b>(&a/int, &b/int) <: &fn<a>(&a/int, &a/int)? (Yes)
+    fn<a,b>(&'a int, &'b int) <: &fn<a>(&'a int, &'a int)? (Yes)
-    fn<a>(&a/int, &a/int) <: &fn<a,b>(&a/int, &b/int)? (No)
+    fn<a>(&'a int, &'a int) <: &fn<a,b>(&'a int, &'b int)? (No)
 
 Here, it is true that functions which take two pointers with any two
 lifetimes can be treated as if they only accepted two pointers with
@@ -221,12 +221,12 @@ Let's walk through some examples and see how this algorithm plays out.
 
 We'll start with the first example, which was:
 
-    1. fn<a>(&a/T) <: &fn<b>(&b/T)?        Yes: a -> b
+    1. fn<a>(&'a T) <: &fn<b>(&'b T)?        Yes: a -> b
 
 After steps 1 and 2 of the algorithm we will have replaced the types
 like so:
 
-    1. fn(&A/T) <: &fn(&x/T)?
+    1. fn(&'A T) <: &fn(&'x T)?
 
 Here the upper case `&A` indicates a *region variable*, that is, a
 region whose value is being inferred by the system.  I also replaced
@@ -238,7 +238,7 @@ region names anymore (as indicated by the absence of `<` and `>`).
 The next step is to check that the parameter types match.  Because
 parameters are contravariant, this means that we check whether:
 
-    &x/T <: &A/T
+    &'x T <: &'A T
 
 Region pointers are contravariant so this implies that
 
@@ -255,12 +255,12 @@ So far we have encountered no error, so the subtype check succeeds.
 
 Now let's look first at the third example, which was:
 
-    3. fn(&self/T)    <: &fn<b>(&b/T)?        No!
+    3. fn(&'self T)    <: &fn<b>(&'b T)?        No!
 
 After steps 1 and 2 of the algorithm we will have replaced the types
 like so:
 
-    3. fn(&self/T) <: &fn(&x/T)?
+    3. fn(&'self T) <: &fn(&'x T)?
 
 This looks pretty much the same as before, except that on the LHS
 `&self` was not bound, and hence was left as-is and not replaced with
@@ -275,33 +275,33 @@ You may be wondering about that mysterious last step in the algorithm.
 So far it has not been relevant.  The purpose of that last step is to
 catch something like *this*:
 
-    fn<a>() -> fn(&a/T) <: &fn() -> fn<b>(&b/T)?   No.
+    fn<a>() -> fn(&'a T) <: &fn() -> fn<b>(&'b T)?   No.
 
 Here the function types are the same but for where the binding occurs.
 The subtype returns a function that expects a value in precisely one
 region.  The supertype returns a function that expects a value in any
 region.  If we allow an instance of the subtype to be used where the
 supertype is expected, then, someone could call the fn and think that
-the return value has type `fn<b>(&b/T)` when it really has type
+the return value has type `fn<b>(&'b T)` when it really has type
-`fn(&a/T)` (this is case #3, above).  Bad.
+`fn(&'a T)` (this is case #3, above).  Bad.
 
 So let's step through what happens when we perform this subtype check.
 We first replace the bound regions in the subtype (the supertype has
 no bound regions).  This gives us:
 
-    fn() -> fn(&A/T) <: &fn() -> fn<b>(&b/T)?
+    fn() -> fn(&'A T) <: &fn() -> fn<b>(&'b T)?
 
 Now we compare the return types, which are covariant, and hence we have:
 
-    fn(&A/T) <: &fn<b>(&b/T)?
+    fn(&'A T) <: &fn<b>(&'b T)?
 
 Here we skolemize the bound region in the supertype to yield:
 
-    fn(&A/T) <: &fn(&x/T)?
+    fn(&'A T) <: &fn(&'x T)?
 
 And then proceed to compare the argument types:
 
-    &x/T <: &A/T
+    &'x T <: &'A T
     &A <= &x
 
 Finally, this is where it gets interesting!  This is where an error
@@ -314,7 +314,7 @@ The difference between this example and the first one is that the variable
 `A` already existed at the point where the skolemization occurred.  In
 the first example, you had two functions:
 
-    fn<a>(&a/T) <: &fn<b>(&b/T)
+    fn<a>(&'a T) <: &fn<b>(&'b T)
 
 and hence `&A` and `&x` were created "together".  In general, the
 intention of the skolemized names is that they are supposed to be

src/librustc/middle/typeck/infer/unify.rs

@@ -35,8 +35,8 @@ pub struct Node<V, T> {
 }
 
 pub trait UnifyVid<T> {
-    static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
+    static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt)
-        -> &v/mut ValsAndBindings<Self, T>;
+        -> &'v mut ValsAndBindings<Self, T>;
 }
 
 pub impl InferCtxt {
@@ -235,15 +235,15 @@ pub impl InferCtxt {
 // ______________________________________________________________________
 
 impl UnifyVid<Bounds<ty::t>> for ty::TyVid {
-    static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
+    static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt)
-        -> &v/mut ValsAndBindings<ty::TyVid, Bounds<ty::t>> {
+        -> &'v mut ValsAndBindings<ty::TyVid, Bounds<ty::t>> {
         return &mut infcx.ty_var_bindings;
     }
 }
 
 impl UnifyVid<Option<IntVarValue>> for ty::IntVid {
-    static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
+    static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt)
-        -> &v/mut ValsAndBindings<ty::IntVid, Option<IntVarValue>> {
+        -> &'v mut ValsAndBindings<ty::IntVid, Option<IntVarValue>> {
         return &mut infcx.int_var_bindings;
     }
 }
@@ -256,8 +256,8 @@ impl SimplyUnifiable for IntVarValue {
 }
 
 impl UnifyVid<Option<ast::float_ty>> for ty::FloatVid {
-    static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
+    static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt)
-        -> &v/mut ValsAndBindings<ty::FloatVid, Option<ast::float_ty>> {
+        -> &'v mut ValsAndBindings<ty::FloatVid, Option<ast::float_ty>> {
         return &mut infcx.float_var_bindings;
     }
 }

src/libstd/arc.rs

@@ -27,8 +27,8 @@ use core::task;
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signalling.
 pub struct Condvar {
     is_mutex: bool,
-    failed: &self/mut bool,
+    failed: &'self mut bool,
-    cond: &self/sync::Condvar/&self
+    cond: &'self sync::Condvar/&self
 }
 
 pub impl Condvar/&self {
@@ -95,7 +95,7 @@ pub fn ARC<T:Const + Owned>(data: T) -> ARC<T> {
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-pub fn get<T:Const + Owned>(rc: &a/ARC<T>) -> &a/T {
+pub fn get<T:Const + Owned>(rc: &'a ARC<T>) -> &'a T {
     unsafe { get_shared_immutable_state(&rc.x) }
 }
 
@@ -193,7 +193,7 @@ pub impl<T:Owned> MutexARC<T> {
     #[inline(always)]
     unsafe fn access_cond<U>(
         &self,
-        blk: &fn(x: &x/mut T, c: &c/Condvar) -> U) -> U
+        blk: &fn(x: &'x mut T, c: &'c Condvar) -> U) -> U
     {
         unsafe {
             let state = get_shared_mutable_state(&self.x);
@@ -239,7 +239,7 @@ impl Drop for PoisonOnFail {
     }
 }
 
-fn PoisonOnFail(failed: &r/mut bool) -> PoisonOnFail {
+fn PoisonOnFail(failed: &'r mut bool) -> PoisonOnFail {
     PoisonOnFail {
         failed: ptr::to_mut_unsafe_ptr(failed)
     }
@@ -313,7 +313,7 @@ pub impl<T:Const + Owned> RWARC<T> {
     }
     /// As write(), but with a condvar, as sync::rwlock.write_cond().
     #[inline(always)]
-    fn write_cond<U>(&self, blk: &fn(x: &x/mut T, c: &c/Condvar) -> U) -> U {
+    fn write_cond<U>(&self, blk: &fn(x: &'x mut T, c: &'c Condvar) -> U) -> U {
         unsafe {
             let state = get_shared_mutable_state(&self.x);
             do (*borrow_rwlock(state)).write_cond |cond| {
@@ -436,7 +436,7 @@ pub impl<T:Const + Owned> RWWriteMode/&self<T> {
         }
     }
     /// Access the pre-downgrade RWARC in write mode with a condvar.
-    fn write_cond<U>(&self, blk: &fn(x: &x/mut T, c: &c/Condvar) -> U) -> U {
+    fn write_cond<U>(&self, blk: &fn(x: &'x mut T, c: &'c Condvar) -> U) -> U {
         match *self {
             RWWriteMode {
                 data: ref data,

src/libstd/arena.rs

@@ -201,7 +201,7 @@ pub impl Arena {
     }
 
     #[inline(always)]
-    fn alloc_pod<T>(&self, op: &fn() -> T) -> &self/T {
+    fn alloc_pod<T>(&self, op: &fn() -> T) -> &'self T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
@@ -246,7 +246,7 @@ pub impl Arena {
     }
 
     #[inline(always)]
-    fn alloc_nonpod<T>(&self, op: &fn() -> T) -> &self/T {
+    fn alloc_nonpod<T>(&self, op: &fn() -> T) -> &'self T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
             let (ty_ptr, ptr) =
@@ -268,7 +268,7 @@ pub impl Arena {
 
     // The external interface
     #[inline(always)]
-    fn alloc<T>(&self, op: &fn() -> T) -> &self/T {
+    fn alloc<T>(&self, op: &fn() -> T) -> &'self T {
         unsafe {
             if !rusti::needs_drop::<T>() {
                 self.alloc_pod(op)

src/libstd/base64.rs

@@ -16,7 +16,7 @@ pub trait ToBase64 {
     pure fn to_base64(&self) -> ~str;
 }
 
-impl ToBase64 for &self/[u8] {
+impl ToBase64 for &'self [u8] {
     pure fn to_base64(&self) -> ~str {
         let chars = str::chars(
           ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
@@ -69,7 +69,7 @@ impl ToBase64 for &self/[u8] {
     }
 }
 
-impl ToBase64 for &self/str {
+impl ToBase64 for &'self str {
     pure fn to_base64(&self) -> ~str {
         str::to_bytes(*self).to_base64()
     }

src/libstd/bigint.rs

@@ -1045,9 +1045,9 @@ mod biguint_tests {
         fail_unless!(BigUint::new(~[0, 0, -1]).to_uint() == uint::max_value);
     }
 
-    const sum_triples: &static/[(&static/[BigDigit],
+    const sum_triples: &'static [(&'static [BigDigit],
-                                 &static/[BigDigit],
+                                 &'static [BigDigit],
-                                 &static/[BigDigit])] = &[
+                                 &'static [BigDigit])] = &[
         (&[],          &[],       &[]),
         (&[],          &[ 1],     &[ 1]),
         (&[ 1],        &[ 1],     &[ 2]),
@@ -1085,9 +1085,9 @@ mod biguint_tests {
         }
     }
 
-    const mul_triples: &static/[(&static/[BigDigit],
+    const mul_triples: &'static [(&'static [BigDigit],
-                                 &static/[BigDigit],
+                                 &'static [BigDigit],
-                                 &static/[BigDigit])] = &[
+                                 &'static [BigDigit])] = &[
         (&[],               &[],               &[]),
         (&[],               &[ 1],             &[]),
         (&[ 2],             &[],               &[]),
@@ -1111,10 +1111,10 @@ mod biguint_tests {
         (&[ 0,  0,  1],     &[ 0,  0,  0,  1], &[0, 0,  0,  0,  0,  1])
     ];
 
-    const divmod_quadruples: &static/[(&static/[BigDigit],
+    const divmod_quadruples: &'static [(&'static [BigDigit],
-                                       &static/[BigDigit],
+                                       &'static [BigDigit],
-                                       &static/[BigDigit],
+                                       &'static [BigDigit],
-                                       &static/[BigDigit])]
+                                       &'static [BigDigit])]
         = &[
             (&[ 1],        &[ 2], &[],               &[1]),
             (&[ 1,  1],    &[ 2], &[-1/2+1],         &[1]),
@@ -1399,9 +1399,9 @@ mod bigint_tests {
         ).to_uint() == 0);
     }
 
-    const sum_triples: &static/[(&static/[BigDigit],
+    const sum_triples: &'static [(&'static [BigDigit],
-                                 &static/[BigDigit],
+                                 &'static [BigDigit],
-                                 &static/[BigDigit])] = &[
+                                 &'static [BigDigit])] = &[
         (&[],          &[],       &[]),
         (&[],          &[ 1],     &[ 1]),
         (&[ 1],        &[ 1],     &[ 2]),
@@ -1451,9 +1451,9 @@ mod bigint_tests {
         }
     }
 
-    const mul_triples: &static/[(&static/[BigDigit],
+    const mul_triples: &'static [(&'static [BigDigit],
-                                 &static/[BigDigit],
+                                 &'static [BigDigit],
-                                 &static/[BigDigit])] = &[
+                                 &'static [BigDigit])] = &[
         (&[],               &[],               &[]),
         (&[],               &[ 1],             &[]),
         (&[ 2],             &[],               &[]),
@@ -1477,10 +1477,10 @@ mod bigint_tests {
         (&[ 0,  0,  1],     &[ 0,  0,  0,  1], &[0, 0,  0,  0,  0,  1])
     ];
 
-    const divmod_quadruples: &static/[(&static/[BigDigit],
+    const divmod_quadruples: &'static [(&'static [BigDigit],
-                                       &static/[BigDigit],
+                                       &'static [BigDigit],
-                                       &static/[BigDigit],
+                                       &'static [BigDigit],
-                                       &static/[BigDigit])]
+                                       &'static [BigDigit])]
         = &[
             (&[ 1],        &[ 2], &[],               &[1]),
             (&[ 1,  1],    &[ 2], &[-1/2+1],         &[1]),

src/libstd/deque.rs

@@ -49,17 +49,17 @@ pub impl<T> Deque<T> {
     /// Return a reference to the first element in the deque
     ///
     /// Fails if the deque is empty
-    fn peek_front(&self) -> &self/T { get(self.elts, self.lo) }
+    fn peek_front(&self) -> &'self T { get(self.elts, self.lo) }
 
     /// Return a reference to the last element in the deque
     ///
     /// Fails if the deque is empty
-    fn peek_back(&self) -> &self/T { get(self.elts, self.hi - 1u) }
+    fn peek_back(&self) -> &'self T { get(self.elts, self.hi - 1u) }
 
     /// Retrieve an element in the deque by index
     ///
     /// Fails if there is no element with the given index
-    fn get(&self, i: int) -> &self/T {
+    fn get(&self, i: int) -> &'self T {
         let idx = (self.lo + (i as uint)) % self.elts.len();
         get(self.elts, idx)
     }
@@ -130,7 +130,7 @@ fn grow<T>(nelts: uint, lo: uint, elts: &mut [Option<T>]) -> ~[Option<T>] {
     rv
 }
 
-fn get<T>(elts: &r/[Option<T>], i: uint) -> &r/T {
+fn get<T>(elts: &'r [Option<T>], i: uint) -> &'r T {
     match elts[i] { Some(ref t) => t, _ => fail!() }
 }
 

src/libstd/future.rs

@@ -55,7 +55,7 @@ pub impl<A:Copy> Future<A> {
 
 pub impl<A> Future<A> {
 
-    pure fn get_ref(&self) -> &self/A {
+    pure fn get_ref(&self) -> &'self A {
         /*!
         * Executes the future's closure and then returns a borrowed
         * pointer to the result.  The borrowed pointer lasts as long as

src/libstd/json.rs

@@ -748,7 +748,7 @@ pub fn from_str(s: &str) -> Result<Json, Error> {
 
 pub struct Decoder {
     priv json: Json,
-    priv mut stack: ~[&self/Json],
+    priv mut stack: ~[&'self Json],
 }
 
 pub fn Decoder(json: Json) -> Decoder {
@@ -756,12 +756,12 @@ pub fn Decoder(json: Json) -> Decoder {
 }
 
 priv impl Decoder/&self {
-    fn peek(&self) -> &self/Json {
+    fn peek(&self) -> &'self Json {
         if self.stack.len() == 0 { self.stack.push(&self.json); }
         self.stack[self.stack.len() - 1]
     }
 
-    fn pop(&self) -> &self/Json {
+    fn pop(&self) -> &'self Json {
         if self.stack.len() == 0 { self.stack.push(&self.json); }
         self.stack.pop()
     }

src/libstd/priority_queue.rs

@@ -50,10 +50,10 @@ impl<T:Ord> Mutable for PriorityQueue<T> {
 
 pub impl <T:Ord> PriorityQueue<T> {
     /// Returns the greatest item in the queue - fails if empty
-    pure fn top(&self) -> &self/T { &self.data[0] }
+    pure fn top(&self) -> &'self T { &self.data[0] }
 
     /// Returns the greatest item in the queue - None if empty
-    pure fn maybe_top(&self) -> Option<&self/T> {
+    pure fn maybe_top(&self) -> Option<&'self T> {
         if self.is_empty() { None } else { Some(self.top()) }
     }
 

src/libstd/serialize.rs

@@ -213,7 +213,7 @@ impl<D:Decoder> Decodable<D> for i64 {
     }
 }
 
-impl<S:Encoder> Encodable<S> for &self/str {
+impl<S:Encoder> Encodable<S> for &'self str {
     fn encode(&self, s: &S) { s.emit_borrowed_str(*self) }
 }
 
@@ -286,7 +286,7 @@ impl<D:Decoder> Decodable<D> for () {
     }
 }
 
-impl<S:Encoder,T:Encodable<S>> Encodable<S> for &self/T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for &'self T {
     fn encode(&self, s: &S) {
         s.emit_borrowed(|| (**self).encode(s))
     }
@@ -316,7 +316,7 @@ impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
     }
 }
 
-impl<S:Encoder,T:Encodable<S>> Encodable<S> for &self/[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for &'self [T] {
     fn encode(&self, s: &S) {
         do s.emit_borrowed_vec(self.len()) {
             for self.eachi |i, e| {

src/libstd/smallintmap.rs

@@ -22,9 +22,9 @@ pub struct SmallIntMap<T> {
     priv v: ~[Option<T>],
 }
 
-impl<V> BaseIter<(uint, &self/V)> for SmallIntMap<V> {
+impl<V> BaseIter<(uint, &'self V)> for SmallIntMap<V> {
     /// Visit all key-value pairs in order
-    pure fn each(&self, it: &fn(&(uint, &self/V)) -> bool) {
+    pure fn each(&self, it: &fn(&(uint, &'self V)) -> bool) {
         for uint::range(0, self.v.len()) |i| {
             match self.v[i] {
               Some(ref elt) => if !it(&(i, elt)) { break },
@@ -36,9 +36,9 @@ impl<V> BaseIter<(uint, &self/V)> for SmallIntMap<V> {
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
-impl<V> ReverseIter<(uint, &self/V)> for SmallIntMap<V> {
+impl<V> ReverseIter<(uint, &'self V)> for SmallIntMap<V> {
     /// Visit all key-value pairs in reverse order
-    pure fn each_reverse(&self, it: &fn(&(uint, &self/V)) -> bool) {
+    pure fn each_reverse(&self, it: &fn(&(uint, &'self V)) -> bool) {
         for uint::range_rev(self.v.len(), 0) |i| {
             match self.v[i - 1] {
               Some(ref elt) => if !it(&(i - 1, elt)) { break },
@@ -96,7 +96,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
     }
 
     /// Iterate over the map and mutate the contained values
-    pure fn find(&self, key: &uint) -> Option<&self/V> {
+    pure fn find(&self, key: &uint) -> Option<&'self V> {
         if *key < self.v.len() {
             match self.v[*key] {
               Some(ref value) => Some(value),
@@ -136,7 +136,7 @@ pub impl<V> SmallIntMap<V> {
     /// Create an empty SmallIntMap
     static pure fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} }
 
-    pure fn get(&self, key: &uint) -> &self/V {
+    pure fn get(&self, key: &uint) -> &'self V {
         self.find(key).expect("key not present")
     }
 }

src/libstd/sort.rs

@@ -16,7 +16,7 @@ use core::util;
 use core::vec::{len, push};
 use core::vec;
 
-type Le<T> = &self/pure fn(v1: &T, v2: &T) -> bool;
+type Le<T> = &'self pure fn(v1: &T, v2: &T) -> bool;
 
 /**
  * Merge sort. Returns a new vector containing the sorted list.
@@ -168,7 +168,7 @@ pub trait Sort {
     fn qsort(self);
 }
 
-impl<T:Copy + Ord + Eq> Sort for &self/mut [T] {
+impl<T:Copy + Ord + Eq> Sort for &'self mut [T] {
     fn qsort(self) { quick_sort3(self); }
 }
 
@@ -868,7 +868,7 @@ mod tests {
     #[test]
     pub fn test_merge_sort_stability() {
         // tjc: funny that we have to use parens
-        pure fn ile(x: &(&static/str), y: &(&static/str)) -> bool
+        pure fn ile(x: &(&'static str), y: &(&'static str)) -> bool
         {
             unsafe // to_lower is not pure...
             {
@@ -1172,7 +1172,7 @@ mod big_tests {
 
     struct LVal {
         val: uint,
-        key: &self/fn(@uint),
+        key: &'self fn(@uint),
     }
 
     impl Drop for LVal/&self {
@@ -1190,16 +1190,16 @@ mod big_tests {
     }
 
     impl Ord for LVal/&self {
-        pure fn lt(&self, other: &a/LVal/&self) -> bool {
+        pure fn lt(&self, other: &'a LVal/&self) -> bool {
             (*self).val < other.val
         }
-        pure fn le(&self, other: &a/LVal/&self) -> bool {
+        pure fn le(&self, other: &'a LVal/&self) -> bool {
             (*self).val <= other.val
         }
-        pure fn gt(&self, other: &a/LVal/&self) -> bool {
+        pure fn gt(&self, other: &'a LVal/&self) -> bool {
             (*self).val > other.val
         }
-        pure fn ge(&self, other: &a/LVal/&self) -> bool {
+        pure fn ge(&self, other: &'a LVal/&self) -> bool {
             (*self).val >= other.val
         }
     }

src/libstd/stats.rs

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

src/libstd/sync.rs

@@ -165,7 +165,7 @@ pub impl Sem<~[Waitqueue]> {
 #[doc(hidden)]
 type SemRelease = SemReleaseGeneric/&self<()>;
 type SemAndSignalRelease = SemReleaseGeneric/&self<~[Waitqueue]>;
-struct SemReleaseGeneric<Q> { sem: &self/Sem<Q> }
+struct SemReleaseGeneric<Q> { sem: &'self Sem<Q> }
 
 impl<Q:Owned> Drop for SemReleaseGeneric/&self<Q> {
     fn finalize(&self) {
@@ -173,13 +173,13 @@ impl<Q:Owned> Drop for SemReleaseGeneric/&self<Q> {
     }
 }
 
-fn SemRelease(sem: &r/Sem<()>) -> SemRelease/&r {
+fn SemRelease(sem: &'r Sem<()>) -> SemRelease/&r {
     SemReleaseGeneric {
         sem: sem
     }
 }
 
-fn SemAndSignalRelease(sem: &r/Sem<~[Waitqueue]>)
+fn SemAndSignalRelease(sem: &'r Sem<~[Waitqueue]>)
     -> SemAndSignalRelease/&r {
     SemReleaseGeneric {
         sem: sem
@@ -187,7 +187,7 @@ fn SemAndSignalRelease(sem: &r/Sem<~[Waitqueue]>)
 }
 
 /// A mechanism for atomic-unlock-and-deschedule blocking and signalling.
-pub struct Condvar { priv sem: &self/Sem<~[Waitqueue]> }
+pub struct Condvar { priv sem: &'self Sem<~[Waitqueue]> }
 
 impl Drop for Condvar/&self { fn finalize(&self) {} }
 
@@ -258,7 +258,7 @@ pub impl Condvar/&self {
         // mutex during unwinding. As long as the wrapper (mutex, etc) is
         // bounded in when it gets released, this shouldn't hang forever.
         struct SemAndSignalReacquire {
-            sem: &self/Sem<~[Waitqueue]>,
+            sem: &'self Sem<~[Waitqueue]>,
         }
 
         impl Drop for SemAndSignalReacquire/&self {
@@ -272,7 +272,7 @@ pub impl Condvar/&self {
             }
         }
 
-        fn SemAndSignalReacquire(sem: &r/Sem<~[Waitqueue]>)
+        fn SemAndSignalReacquire(sem: &'r Sem<~[Waitqueue]>)
             -> SemAndSignalReacquire/&r {
             SemAndSignalReacquire {
                 sem: sem
@@ -610,7 +610,7 @@ pub impl RWlock {
 // FIXME(#3588) should go inside of read()
 #[doc(hidden)]
 struct RWlockReleaseRead {
-    lock: &self/RWlock,
+    lock: &'self RWlock,
 }
 
 impl Drop for RWlockReleaseRead/&self {
@@ -635,7 +635,7 @@ impl Drop for RWlockReleaseRead/&self {
     }
 }
 
-fn RWlockReleaseRead(lock: &r/RWlock) -> RWlockReleaseRead/&r {
+fn RWlockReleaseRead(lock: &'r RWlock) -> RWlockReleaseRead/&r {
     RWlockReleaseRead {
         lock: lock
     }
@@ -644,7 +644,7 @@ fn RWlockReleaseRead(lock: &r/RWlock) -> RWlockReleaseRead/&r {
 // FIXME(#3588) should go inside of downgrade()
 #[doc(hidden)]
 struct RWlockReleaseDowngrade {
-    lock: &self/RWlock,
+    lock: &'self RWlock,
 }
 
 impl Drop for RWlockReleaseDowngrade/&self {
@@ -677,18 +677,18 @@ impl Drop for RWlockReleaseDowngrade/&self {
     }
 }
 
-fn RWlockReleaseDowngrade(lock: &r/RWlock) -> RWlockReleaseDowngrade/&r {
+fn RWlockReleaseDowngrade(lock: &'r RWlock) -> RWlockReleaseDowngrade/&r {
     RWlockReleaseDowngrade {
         lock: lock
     }
 }
 
 /// The "write permission" token used for rwlock.write_downgrade().
-pub struct RWlockWriteMode { priv lock: &self/RWlock }
+pub struct RWlockWriteMode { priv lock: &'self RWlock }
 impl Drop for RWlockWriteMode/&self { fn finalize(&self) {} }
 
 /// The "read permission" token used for rwlock.write_downgrade().
-pub struct RWlockReadMode  { priv lock: &self/RWlock }
+pub struct RWlockReadMode  { priv lock: &'self RWlock }
 impl Drop for RWlockReadMode/&self { fn finalize(&self) {} }
 
 pub impl RWlockWriteMode/&self {

src/libstd/test.rs

@@ -49,7 +49,7 @@ pub mod rustrt {
 // hierarchically it may.
 
 pub enum TestName {
-    StaticTestName(&static/str),
+    StaticTestName(&'static str),
     DynTestName(~str)
 }
 impl ToStr for TestName {

src/libstd/treemap.rs

@@ -88,7 +88,7 @@ impl<K: Ord + TotalOrd, V> Ord for TreeMap<K, V> {
 
 impl<'self, K: TotalOrd, V> BaseIter<(&'self K, &'self V)> for TreeMap<K, V> {
     /// Visit all key-value pairs in order
-    pure fn each(&self, f: &fn(&(&self/K, &self/V)) -> bool) {
+    pure fn each(&self, f: &fn(&(&'self K, &'self V)) -> bool) {
         each(&self.root, f)
     }
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
@@ -99,7 +99,7 @@ impl<'self, K: TotalOrd, V>
     for TreeMap<K, V>
 {
     /// Visit all key-value pairs in reverse order
-    pure fn each_reverse(&self, f: &fn(&(&self/K, &self/V)) -> bool) {
+    pure fn each_reverse(&self, f: &fn(&(&'self K, &'self V)) -> bool) {
         each_reverse(&self.root, f);
     }
 }
@@ -140,8 +140,8 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
     }
 
     /// Return the value corresponding to the key in the map
-    pure fn find(&self, key: &K) -> Option<&self/V> {
+    pure fn find(&self, key: &K) -> Option<&'self V> {
-        let mut current: &self/Option<~TreeNode<K, V>> = &self.root;
+        let mut current: &'self Option<~TreeNode<K, V>> = &self.root;
         loop {
             match *current {
               Some(ref r) => {
@@ -197,15 +197,15 @@ pub impl<K: TotalOrd, V> TreeMap<K, V> {
 
 /// Lazy forward iterator over a map
 pub struct TreeMapIterator<K, V> {
-    priv stack: ~[&self/~TreeNode<K, V>],
+    priv stack: ~[&'self ~TreeNode<K, V>],
-    priv node: &self/Option<~TreeNode<K, V>>
+    priv node: &'self Option<~TreeNode<K, V>>
 }
 
 /// Advance the iterator to the next node (in order) and return a
 /// tuple with a reference to the key and value. If there are no
 /// more nodes, return `None`.
 pub fn map_next<K, V>(iter: &mut TreeMapIterator/&r<K, V>)
-                        -> Option<(&r/K, &r/V)> {
+                        -> Option<(&'r K, &'r V)> {
     while !iter.stack.is_empty() || iter.node.is_some() {
         match *iter.node {
           Some(ref x) => {
@@ -224,7 +224,7 @@ pub fn map_next<K, V>(iter: &mut TreeMapIterator/&r<K, V>)
 
 /// Advance the iterator through the map
 pub fn map_advance<K, V>(iter: &mut TreeMapIterator/&r<K, V>,
-                         f: &fn((&r/K, &r/V)) -> bool) {
+                         f: &fn((&'r K, &'r V)) -> bool) {
     loop {
         match map_next(iter) {
           Some(x) => {
@@ -519,14 +519,14 @@ pub struct TreeSetIterator<T> {
 /// Advance the iterator to the next node (in order). If this iterator is
 /// finished, does nothing.
 #[inline(always)]
-pub fn set_next<T>(iter: &mut TreeSetIterator/&r<T>) -> Option<&r/T> {
+pub fn set_next<T>(iter: &mut TreeSetIterator/&r<T>) -> Option<&'r T> {
     do map_next(&mut iter.iter).map |&(value, _)| { value }
 }
 
 /// Advance the iterator through the set
 #[inline(always)]
 pub fn set_advance<T>(iter: &mut TreeSetIterator/&r<T>,
-                      f: &fn(&r/T) -> bool) {
+                      f: &fn(&'r T) -> bool) {
     do map_advance(&mut iter.iter) |(k, _)| { f(k) }
 }
 
@@ -547,16 +547,16 @@ pub impl<K: TotalOrd, V> TreeNode<K, V> {
     }
 }
 
-pure fn each<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
+pure fn each<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
-                             f: &fn(&(&r/K, &r/V)) -> bool) {
+                             f: &fn(&(&'r K, &'r V)) -> bool) {
     for node.each |x| {
         each(&x.left, f);
         if f(&(&x.key, &x.value)) { each(&x.right, f) }
     }
 }
 
-pure fn each_reverse<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
+pure fn each_reverse<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>,
-                                     f: &fn(&(&r/K, &r/V)) -> bool) {
+                                     f: &fn(&(&'r K, &'r V)) -> bool) {
     for node.each |x| {
         each_reverse(&x.right, f);
         if f(&(&x.key, &x.value)) { each_reverse(&x.left, f) }

src/libsyntax/ext/base.rs

@@ -421,7 +421,7 @@ pub fn get_exprs_from_tts(cx: @ext_ctxt, tts: &[ast::token_tree])
 // use a top-level managed pointer by some difficulties
 // with pushing and popping functionally, and the ownership
 // issues.  As a result, the values returned by the table
-// also need to be managed; the &self/... type that Maps
+// also need to be managed; the &'self ... type that Maps
 // return won't work for things that need to get outside
 // of that managed pointer.  The easiest way to do this
 // is just to insist that the values in the tables are
@@ -454,7 +454,7 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{
 
     // ugh: can't get this to compile with mut because of the
     // lack of flow sensitivity.
-    fn get_map(&self) -> &self/LinearMap<K,@V> {
+    fn get_map(&self) -> &'self LinearMap<K,@V> {
         match *self {
             BaseMapChain (~ref map) => map,
             ConsMapChain (~ref map,_) => map

src/libsyntax/ext/deriving.rs

@@ -45,12 +45,12 @@ pub impl Junction {
     }
 }
 
-type ExpandDerivingStructDefFn = &self/fn(@ext_ctxt,
+type ExpandDerivingStructDefFn = &'self fn(@ext_ctxt,
                                           span,
                                           x: &struct_def,
                                           ident,
                                           y: &Generics) -> @item;
-type ExpandDerivingEnumDefFn = &self/fn(@ext_ctxt,
+type ExpandDerivingEnumDefFn = &'self fn(@ext_ctxt,
                                         span,
                                         x: &enum_def,
                                         ident,

src/libsyntax/ext/quote.rs

@@ -392,6 +392,12 @@ fn mk_token(cx: @ext_ctxt, sp: span, tok: token::Token) -> @ast::expr {
                                     build::mk_lit(cx, sp, ast::lit_bool(b))]);
         }
 
+        LIFETIME(ident) => {
+            return build::mk_call(cx, sp,
+                                  ids_ext(cx, ~[~"LIFETIME"]),
+                                  ~[mk_ident(cx, sp, ident)]);
+        }
+
         DOC_COMMENT(ident) => {
             return build::mk_call(cx, sp,
                                   ids_ext(cx, ~[~"DOC_COMMENT"]),

src/libsyntax/opt_vec.rs

@@ -61,7 +61,7 @@ impl<T> OptVec<T> {
         }
     }
 
-    pure fn get(&self, i: uint) -> &self/T {
+    pure fn get(&self, i: uint) -> &'self T {
         match *self {
             Empty => fail!(fmt!("Invalid index %u", i)),
             Vec(ref v) => &v[i]

src/libsyntax/parse/parser.rs

@@ -708,7 +708,7 @@ pub impl Parser {
     }
 
     fn parse_borrowed_pointee(&self) -> ty_ {
-        // look for `&'lt` or `&foo/` and interpret `foo` as the region name:
+        // look for `&'lt` or `&'foo ` and interpret `foo` as the region name:
         let opt_lifetime = self.parse_opt_lifetime();
 
         if self.token_is_closure_keyword(&copy *self.token) {

src/test/auxiliary/cci_const.rs

@@ -11,6 +11,6 @@
 pub extern fn bar() {
 }
 
-pub const foopy: &static/str = "hi there";
+pub const foopy: &'static str = "hi there";
 pub const uint_val: uint = 12;
 pub const uint_expr: uint = (1 << uint_val) - 1;

src/test/compile-fail/borrowck-addr-of-upvar.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: @int) -> @fn() -> &static/int {
+fn foo(x: @int) -> @fn() -> &'static int {
-    let result: @fn() -> &static/int = || &*x;  //~ ERROR illegal borrow
+    let result: @fn() -> &'static int = || &*x;  //~ ERROR illegal borrow
     result
 }
 

src/test/compile-fail/const-cast-different-types.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-const a: &static/str = &"foo";
+const a: &'static str = &"foo";
 const b: *u8 = a as *u8; //~ ERROR non-scalar cast
 const c: *u8 = &a as *u8; //~ ERROR mismatched types
 

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

@@ -22,6 +22,6 @@ impl<A> vec_monad<A> for ~[A] {
 }
 fn main() {
     ["hi"].bind(|x| [x] );
-    //~^ ERROR type `[&static/str * 1]` does not implement any method in scope named `bind`
+    //~^ ERROR type `[&'static str * 1]` does not implement any method in scope named `bind`
     //~^^ ERROR Unconstrained region variable
 }

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

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // xfail-test
-fn foo() -> &a/int {
+fn foo() -> &'a int {
     return &x;
 }
 const x: int = 5;

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

@@ -10,7 +10,7 @@
 
 // xfail-test
 fn function() -> &mut [int] {
-    let mut x: &static/mut [int] = &[1,2,3];
+    let mut x: &'static mut [int] = &[1,2,3];
     x[0] = 12345;
     x //~ ERROR bad
 }

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

@@ -15,7 +15,7 @@ struct Foo {
 }
 
 pub impl Foo<'self> {
-    fn get_s(&self) -> &self/str {
+    fn get_s(&self) -> &'self str {
         self.s
     }
 }

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

@@ -10,7 +10,7 @@
 
 trait A {
   fn a(&self) {
-      || self.b() //~ ERROR type `&self/self` does not implement any method in scope named `b`
+      || self.b() //~ ERROR type `&'self self` does not implement any method in scope named `b`
   }
 }
 fn main() {}

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

@@ -10,7 +10,7 @@
 
 // n.b. This should be a run-pass test, but for now I'm testing
 // that we don't see an "unknown scope" error.
-fn vec_peek<T>(v: &r/[T]) -> Option< (&r/T, &r/[T]) > {
+fn vec_peek<T>(v: &'r [T]) -> Option< (&'r T, &'r [T]) > {
     if v.len() == 0 {
         None
     } else {

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

@@ -11,7 +11,7 @@
 // xfail-test
 fn id<T>(t: T) -> T { t }
 
-fn f<T>(v: &r/T) -> &r/fn()->T { id::<&r/fn()->T>(|| *v) } //~ ERROR ???
+fn f<T>(v: &'r T) -> &'r fn()->T { id::<&'r fn()->T>(|| *v) } //~ ERROR ???
 
 fn main() {
     let v = &5;

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

@@ -10,7 +10,7 @@
 
 fn foopy() {}
 
-const f: &'static fn() = foopy; //~ ERROR mismatched types: expected `&static/fn()`
+const f: &'static fn() = foopy; //~ ERROR mismatched types: expected `&'static fn()`
 
 fn main () {
     f();

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

@@ -21,10 +21,10 @@ fn repeater<A:Copy>(v: @A) -> @repeat<A> {
 
 fn main() {
     // Error results because the type of is inferred to be
-    // @repeat<&blk/int> where blk is the lifetime of the block below.
+    // @repeat<&'blk int> where blk is the lifetime of the block below.
 
     let y = { //~ ERROR reference is not valid
-        let x: &blk/int = &3;
+        let x: &'blk int = &3;
         repeater(@x)
     };
     fail_unless!(3 == *(y.get())); //~ ERROR reference is not valid

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

@@ -12,7 +12,7 @@
 // except according to those terms.
 
 // A dummy trait/impl that work close over any type.  The trait will
-// be parameterized by a region due to the &self/int constraint.
+// be parameterized by a region due to the &'self int constraint.
 
 trait foo {
     fn foo(&self, i: &'self int) -> int;

src/test/compile-fail/regions-addr-of-self.rs

@@ -14,12 +14,12 @@ struct dog {
 
 pub impl dog {
     fn chase_cat(&mut self) {
-        let p: &static/mut uint = &mut self.cats_chased; //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements
+        let p: &'static mut uint = &mut self.cats_chased; //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements
         *p += 1u;
     }
 
     fn chase_cat_2(&mut self) {
-        let p: &blk/mut uint = &mut self.cats_chased;
+        let p: &'blk mut uint = &mut self.cats_chased;
         *p += 1u;
     }
 }

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

@@ -10,13 +10,13 @@
 
 fn foo(cond: bool) {
     let x = 5;
-    let mut y: &blk/int = &x;
+    let mut y: &'blk int = &x;
 
-    let mut z: &blk/int;
+    let mut z: &'blk int;
     if cond {
         z = &x; //~ ERROR cannot infer an appropriate lifetime due to conflicting requirements
     } else {
-        let w: &blk/int = &x;
+        let w: &'blk int = &x;
         z = w;
     }
 }

src/test/compile-fail/regions-fn-bound.rs

@@ -11,7 +11,7 @@
 fn of<T>() -> @fn(T) { fail!(); }
 fn subtype<T>(x: @fn(T)) { fail!(); }
 
-fn test_fn<T>(_x: &x/T, _y: &y/T, _z: &z/T) {
+fn test_fn<T>(_x: &'x T, _y: &'y T, _z: &'z T) {
     // Here, x, y, and z are free.  Other letters
     // are bound.  Note that the arrangement
     // subtype::<T1>(of::<T2>()) will typecheck

src/test/compile-fail/regions-fn-subtyping.rs

@@ -11,47 +11,47 @@
 fn of<T>() -> @fn(T) { fail!(); }
 fn subtype<T>(x: @fn(T)) { fail!(); }
 
-fn test_fn<T>(_x: &x/T, _y: &y/T, _z: &z/T) {
+fn test_fn<T>(_x: &'x T, _y: &'y T, _z: &'z T) {
     // Here, x, y, and z are free.  Other letters
     // are bound.  Note that the arrangement
     // subtype::<T1>(of::<T2>()) will typecheck
     // iff T1 <: T2.
 
-    subtype::<&fn(&a/T)>(
+    subtype::<&fn(&'a T)>(
-        of::<&fn(&a/T)>());
+        of::<&fn(&'a T)>());
 
-    subtype::<&fn(&a/T)>(
+    subtype::<&fn(&'a T)>(
-        of::<&fn(&b/T)>());
+        of::<&fn(&'b T)>());
 
-    subtype::<&fn(&b/T)>(
+    subtype::<&fn(&'b T)>(
-        of::<&fn(&x/T)>());
+        of::<&fn(&'x T)>());
 
-    subtype::<&fn(&x/T)>(
+    subtype::<&fn(&'x T)>(
-        of::<&fn(&b/T)>());  //~ ERROR mismatched types
+        of::<&fn(&'b T)>());  //~ ERROR mismatched types
 
-    subtype::<&fn(&a/T, &b/T)>(
+    subtype::<&fn(&'a T, &'b T)>(
-        of::<&fn(&a/T, &a/T)>());
+        of::<&fn(&'a T, &'a T)>());
 
-    subtype::<&fn(&a/T, &a/T)>(
+    subtype::<&fn(&'a T, &'a T)>(
-        of::<&fn(&a/T, &b/T)>()); //~ ERROR mismatched types
+        of::<&fn(&'a T, &'b T)>()); //~ ERROR mismatched types
 
-    subtype::<&fn(&a/T, &b/T)>(
+    subtype::<&fn(&'a T, &'b T)>(
-        of::<&fn(&x/T, &y/T)>());
+        of::<&fn(&'x T, &'y T)>());
 
-    subtype::<&fn(&x/T, &y/T)>(
+    subtype::<&fn(&'x T, &'y T)>(
-        of::<&fn(&a/T, &b/T)>()); //~ ERROR mismatched types
+        of::<&fn(&'a T, &'b T)>()); //~ ERROR mismatched types
 
-    subtype::<&fn(&x/T) -> @fn(&a/T)>(
+    subtype::<&fn(&'x T) -> @fn(&'a T)>(
-        of::<&fn(&x/T) -> @fn(&a/T)>());
+        of::<&fn(&'x T) -> @fn(&'a T)>());
 
-    subtype::<&fn(&a/T) -> @fn(&a/T)>(
+    subtype::<&fn(&'a T) -> @fn(&'a T)>(
-        of::<&fn(&a/T) -> @fn(&b/T)>()); //~ ERROR mismatched types
+        of::<&fn(&'a T) -> @fn(&'b T)>()); //~ ERROR mismatched types
 
-    subtype::<&fn(&a/T) -> @fn(&a/T)>(
+    subtype::<&fn(&'a T) -> @fn(&'a T)>(
-        of::<&fn(&x/T) -> @fn(&b/T)>()); //~ ERROR mismatched types
+        of::<&fn(&'x T) -> @fn(&'b T)>()); //~ ERROR mismatched types
 
-    subtype::<&fn(&a/T) -> @fn(&b/T)>(
+    subtype::<&fn(&'a T) -> @fn(&'b T)>(
-        of::<&fn(&a/T) -> @fn(&a/T)>());
+        of::<&fn(&'a T) -> @fn(&'a T)>());
 }
 
 fn main() {}

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

@@ -11,8 +11,8 @@
 // Before fn subtyping was properly implemented,
 // we reported errors in this case:
 
-fn not_ok(a: &uint, b: &b/uint) {
+fn not_ok(a: &uint, b: &'b uint) {
-    let mut g: @fn(x: &uint) = |x: &b/uint| {};
+    let mut g: @fn(x: &uint) = |x: &'b uint| {};
     //~^ ERROR mismatched types
     g(a);
 }

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

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn wants_static_fn(_x: &static/fn()) {}
+fn wants_static_fn(_x: &'static fn()) {}
 
 fn main() {
     let i = 3;

src/test/compile-fail/regions-infer-borrow-scope-too-big.rs

@@ -13,7 +13,7 @@ struct point {
     y: int,
 }
 
-fn x_coord(p: &r/point) -> &r/int {
+fn x_coord(p: &'r point) -> &'r int {
     return &p.x;
 }
 

src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn borrow<T>(x: &r/T) -> &r/T {x}
+fn borrow<T>(x: &'r T) -> &'r T {x}
 
 fn foo(cond: &fn() -> bool, box: &fn() -> @int) {
     let mut y: &int;

src/test/compile-fail/regions-infer-call-3.rs

@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn select(x: &r/int, y: &r/int) -> &r/int { x }
+fn select(x: &'r int, y: &'r int) -> &'r int { x }
 
 fn with<T>(f: &fn(x: &int) -> T) -> T {
     f(&20)
 }
 
-fn manip(x: &a/int) -> int {
+fn manip(x: &'a int) -> int {
     let z = do with |y| { select(x, y) };
     //~^ ERROR cannot infer an appropriate lifetime
     *z