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

Author: pcwalton

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 FreeGlue = &self/fn(**TypeDesc, *c_void);
+type DropGlue = &'self fn(**TypeDesc, *c_void);
+type FreeGlue = &'self fn(**TypeDesc, *c_void);
 
 type TaskID = uintptr_t;
 

src/libcore/condition.rs

@@ -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,
-                              f: &fn(&r/T) -> U) -> U {
+pub pure fn map_default<T, U>(opt: &'r Option<T>, def: 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); } }
     }
 
@@ -343,7 +343,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.
@@ -354,7 +354,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)
     }
 
@@ -396,7 +396,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.
@@ -413,7 +413,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.