diff options
| author | Patrick Walton <pcwalton@mimiga.net> | 2013-03-14 11:22:51 -0700 |
|---|---|---|
| committer | Patrick Walton <pcwalton@mimiga.net> | 2013-03-18 17:21:14 -0700 |
| commit | 352c070365c941e174c17574f7fb3231e2981c5d (patch) | |
| tree | 1621d3e503e0112d7dd11d76baf6f61de77e8717 | |
| parent | 7352d919f62350bd24aefe0f188203ebef833fd5 (diff) | |
| download | rust-352c070365c941e174c17574f7fb3231e2981c5d.tar.gz rust-352c070365c941e174c17574f7fb3231e2981c5d.zip | |
librustc: Convert all uses of old lifetime notation to new lifetime notation. rs=delifetiming
147 files changed, 523 insertions, 501 deletions
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 8cd8b297e2f..8d3c8561957 100644 --- a/src/libcore/at_vec.rs +++ b/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)) } } diff --git a/src/libcore/cast.rs b/src/libcore/cast.rs index bc4358db56c..f752f52ce53 100644 --- a/src/libcore/cast.rs +++ b/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) } diff --git a/src/libcore/cleanup.rs b/src/libcore/cleanup.rs index a46e9154703..66eeb339700 100644 --- a/src/libcore/cleanup.rs +++ b/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; diff --git a/src/libcore/condition.rs b/src/libcore/condition.rs index 17d15a8886f..56b690ca8af 100644 --- a/src/libcore/condition.rs +++ b/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> { diff --git a/src/libcore/container.rs b/src/libcore/container.rs index 828678b65f7..efcf1e26534 100644 --- a/src/libcore/container.rs +++ b/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 diff --git a/src/libcore/gc.rs b/src/libcore/gc.rs index 5f84f7f0d19..3449c5ff4ba 100644 --- a/src/libcore/gc.rs +++ b/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. diff --git a/src/libcore/hashmap.rs b/src/libcore/hashmap.rs index cc7dafad169..20d207e9302 100644 --- a/src/libcore/hashmap.rs +++ b/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, diff --git a/src/libcore/io.rs b/src/libcore/io.rs index 4942b058785..dcb9e23b45b 100644 --- a/src/libcore/io.rs +++ b/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 } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index e461cb2c65f..816dc6d2255 100644 --- a/src/libcore/iter.rs +++ b/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); diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 1e3bba64f27..237fc762b3c 100644 --- a/src/libcore/option.rs +++ b/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); } } } @@ -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. diff --git a/src/libcore/os.rs b/src/libcore/os.rs index 746c403c7bf..17ec9df9d56 100644 --- a/src/libcore/os.rs +++ b/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 DLL_PREFIX: &static/str = "lib"; - pub const DLL_SUFFIX: &static/str = ".dylib"; - pub const EXE_SUFFIX: &static/str = ""; + pub const SYSNAME: &'static str = "macos"; + pub const DLL_PREFIX: &'static str = "lib"; + pub const DLL_SUFFIX: &'static str = ".dylib"; + pub const EXE_SUFFIX: &'static str = ""; } pub mod freebsd { - pub const SYSNAME: &static/str = "freebsd"; - pub const DLL_PREFIX: &static/str = "lib"; - pub const DLL_SUFFIX: &static/str = ".so"; - pub const EXE_SUFFIX: &static/str = ""; + pub const SYSNAME: &'static str = "freebsd"; + pub const DLL_PREFIX: &'static str = "lib"; + pub const DLL_SUFFIX: &'static str = ".so"; + pub const EXE_SUFFIX: &'static str = ""; } pub mod linux { - pub const SYSNAME: &static/str = "linux"; - pub const DLL_PREFIX: &static/str = "lib"; - pub const DLL_SUFFIX: &static/str = ".so"; - pub const EXE_SUFFIX: &static/str = ""; + pub const SYSNAME: &'static str = "linux"; + pub const DLL_PREFIX: &'static str = "lib"; + pub const DLL_SUFFIX: &'static str = ".so"; + pub const EXE_SUFFIX: &'static str = ""; } pub mod android { - pub const SYSNAME: &static/str = "android"; - pub const DLL_PREFIX: &static/str = "lib"; - pub const DLL_SUFFIX: &static/str = ".so"; - pub const EXE_SUFFIX: &static/str = ""; + pub const SYSNAME: &'static str = "android"; + pub const DLL_PREFIX: &'static str = "lib"; + pub const DLL_SUFFIX: &'static str = ".so"; + pub const EXE_SUFFIX: &'static str = ""; } pub mod win32 { - pub const SYSNAME: &static/str = "win32"; - pub const DLL_PREFIX: &static/str = ""; - pub const DLL_SUFFIX: &static/str = ".dll"; - pub const EXE_SUFFIX: &static/str = ".exe"; + pub const SYSNAME: &'static str = "win32"; + pub const DLL_PREFIX: &'static str = ""; + pub const DLL_SUFFIX: &'static str = ".dll"; + pub const EXE_SUFFIX: &'static str = ".exe"; } diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index fd823e9dda0..eb385d90354 100644 --- a/src/libcore/pipes.rs +++ b/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() { diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index e6e312d01b9..481a61f4ab7 100644 --- a/src/libcore/ptr.rs +++ b/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) } } diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs index 30c46cd3e35..a0f9fa7e08e 100644 --- a/src/libcore/reflect.rs +++ b/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 } diff --git a/src/libcore/result.rs b/src/libcore/result.rs index e3fd279a996..832071a0ba8 100644 --- a/src/libcore/result.rs +++ b/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) } diff --git a/src/libcore/rt/io.rs b/src/libcore/rt/io.rs index 3a94c01e0a4..55e062de85b 100644 --- a/src/libcore/rt/io.rs +++ b/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 { diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs index 8f315452e5e..69cbbdd2ad4 100644 --- a/src/libcore/rt/sched.rs +++ b/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_task: &self/Task = match last_job { + let last_job: &'self mut CleanupJob = &mut self.cleanup_jobs[0]; + 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); diff --git a/src/libcore/rt/uv.rs b/src/libcore/rt/uv.rs index c947e4dde4c..80224fa523a 100644 --- a/src/libcore/rt/uv.rs +++ b/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()); diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs index f7275652e7f..a971ed92b7e 100644 --- a/src/libcore/rt/uvio.rs +++ b/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 } } } diff --git a/src/libcore/str.rs b/src/libcore/str.rs index 23b14e243b8..3d591af6d3c 100644 --- a/src/libcore/str.rs +++ b/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 starts_with(&self, needle: &a/str) -> bool; + pure fn split_str(&self, sep: &'a str) -> ~[~str]; + pure fn starts_with(&self, needle: &'a str) -> bool; pure fn substr(&self, begin: uint, n: uint) -> ~str; pure fn to_lower(&self) -> ~str; pure fn to_upper(&self) -> ~str; @@ -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 borrow(x: &a/str) -> &a/str { x } + fn t(s: &str, sep: &'a str, i: int, k: &str) { + fn borrow(x: &'a str) -> &'a str { x } let v = split_str(s, sep); fail_unless!(borrow(v[i]) == k); } diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs index 179a33ae43e..f7eceeebc1e 100644 --- a/src/libcore/sys.rs +++ b/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 { diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs index 690b3aedc5a..ccd91709479 100644 --- a/src/libcore/task/local_data.rs +++ b/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 diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs index a0db2525441..0fd373b803f 100644 --- a/src/libcore/task/spawn.rs +++ b/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 { diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs index 60665bcddf6..e5fbad16717 100644 --- a/src/libcore/to_bytes.rs +++ b/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); diff --git a/src/libcore/to_str.rs b/src/libcore/to_str.rs index 8215152ef74..0f2fd699604 100644 --- a/src/libcore/to_str.rs +++ b/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 { diff --git a/src/libcore/trie.rs b/src/libcore/trie.rs index 15b0e160434..26532c1a4ff 100644 --- a/src/libcore/trie.rs +++ b/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> { - let mut node: &self/TrieNode<T> = &self.root; + pure fn find(&self, key: &uint) -> Option<&'self T> { + 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 }, diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index e41ff424012..b4f68466c27 100644 --- a/src/libcore/tuple.rs +++ b/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 second_ref(&self) -> &self/U; + pure fn first_ref(&self) -> &'self T; + 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 { diff --git a/src/libcore/unstable.rs b/src/libcore/unstable.rs index 9b6dcc31234..899d01cd996 100644 --- a/src/libcore/unstable.rs +++ b/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); diff --git a/src/libcore/unstable/finally.rs b/src/libcore/unstable/finally.rs index 5089470e6ef..e8c27ff7d92 100644 --- a/src/libcore/unstable/finally.rs +++ b/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 { diff --git a/src/libcore/unstable/global.rs b/src/libcore/unstable/global.rs index d8ded635291..66033605559 100644 --- a/src/libcore/unstable/global.rs +++ b/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 { diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index f11a63a787d..34d3c022dca 100644 --- a/src/libcore/vec.rs +++ b/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 head(&self) -> &self/T; - pure fn head_opt(&self) -> Option<&self/T>; - pure fn tail(&self) -> &self/[T]; - pure fn tailn(&self, n: uint) -> &self/[T]; - pure fn init(&self) -> &self/[T]; - pure fn initn(&self, n: uint) -> &self/[T]; - pure fn last(&self) -> &self/T; - pure fn last_opt(&self) -> Option<&self/T>; + pure fn view(&self, start: uint, end: uint) -> &'self [T]; + pure fn head(&self) -> &'self T; + pure fn head_opt(&self) -> Option<&'self T>; + pure fn tail(&self) -> &'self [T]; + pure fn tailn(&self, n: uint) -> &'self [T]; + pure fn init(&self) -> &'self [T]; + pure fn initn(&self, n: uint) -> &'self [T]; + pure fn last(&self) -> &'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() { diff --git a/src/librust/rust.rc b/src/librust/rust.rc index 8fd9fea6bae..3ca4ef5efbd 100644 --- a/src/librust/rust.rc +++ b/src/librust/rust.rc @@ -38,23 +38,23 @@ impl ValidUsage { } enum Action { - Exec(&self/str), - Call(&self/fn(args: &[~str]) -> ValidUsage) + Exec(&'self str), + Call(&'self fn(args: &[~str]) -> ValidUsage) } enum UsageSource { - UsgExec(&self/str), - UsgStr(&self/str) + UsgExec(&'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"), diff --git a/src/librustc/front/core_inject.rs b/src/librustc/front/core_inject.rs index b53303c5983..0766dcd2450 100644 --- a/src/librustc/front/core_inject.rs +++ b/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 { diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index 48db758ef42..ddbac4085a7 100644 --- a/src/librustc/front/test.rs +++ b/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); diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 658b32edf21..1864e1c06ae 100644 --- a/src/librustc/metadata/decoder.rs +++ b/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, diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index 4b1260e76d0..efbde04d68e 100644 --- a/src/librustc/metadata/encoder.rs +++ b/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, diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs index 02203222e05..ad5b0274c0d 100644 --- a/src/librustc/metadata/filesearch.rs +++ b/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) } diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index e9cbd2685df..c87b09cde08 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/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], diff --git a/src/librustc/middle/borrowck/gather_loans.rs b/src/librustc/middle/borrowck/gather_loans.rs index f55fae12b45..2893c460fe2 100644 --- a/src/librustc/middle/borrowck/gather_loans.rs +++ b/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, diff --git a/src/librustc/middle/borrowck/preserve.rs b/src/librustc/middle/borrowck/preserve.rs index 328fe1c4f3e..962af48a70c 100644 --- a/src/librustc/middle/borrowck/preserve.rs +++ b/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, diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index 99781a80c62..4b1b0d0200f 100644 --- a/src/librustc/middle/kind.rs +++ b/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, ()>; diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 32567d71cd9..f88be89ad00 100644 --- a/src/librustc/middle/lang_items.rs +++ b/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, diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs index 1227f7859d8..f2e736ac86d 100644 --- a/src/librustc/middle/lint.rs +++ b/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 diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index a96ed9b8fa6..05a697194c8 100644 --- a/src/librustc/middle/region.rs +++ b/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 { ... } - // 3. impl foo for bar { fn m(@self) -> &self/int { ... } } - // 4. impl foo for bar { fn m(&self) -> &self/int { ... } } + // 2. impl foo for &'self int { ... } + // 3. 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, - // add to the worklist/set. Note that &r/ty is contravariant with - // respect to &r, because &r/ty can be used whereever a *smaller* + // if this type directly references a region pointer like &'r ty, + // add to the worklist/set. Note that &'r ty is contravariant with + // 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; diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index 16f3db6a00e..45d64cd864f 100644 --- a/src/librustc/middle/resolve.rs +++ b/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. diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index 80631abaa55..8f0d9eb953f 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/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) { diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index 15888a64e1e..81d85773ccb 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -550,8 +550,8 @@ pub fn trans_call_inner( pub enum CallArgs { - ArgExprs(&self/[@ast::expr]), - ArgVals(&self/[ValueRef]) + ArgExprs(&'self [@ast::expr]), + ArgVals(&'self [ValueRef]) } pub struct Args { diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index 11d3e155202..9b3ec5ef842 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/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); diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs index 3e4486476c0..9f66bb5b468 100644 --- a/src/librustc/middle/trans/tvec.rs +++ b/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 { diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index f455e983690..fcebcaf501e 100644 --- a/src/librustc/middle/ty.rs +++ b/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. diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 61603f7b578..0186ab30464 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/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. diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index d673cf6a39a..929555e3148 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/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], diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 4ff8431d88a..6871496a805 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/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 * } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index ed26812f44d..3d2ed867de1 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -550,8 +550,8 @@ pub impl CoherenceChecker { } fn can_unify_universally_quantified(&self, - a: &a/UniversalQuantificationResult, - b: &a/UniversalQuantificationResult) + a: &'a UniversalQuantificationResult, + b: &'a UniversalQuantificationResult) -> bool { let mut might_unify = true; let _ = do self.inference_context.probe { diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 29d1f81cdd6..b9aac4b19ed 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/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( diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index 5c59f1215e4..1ce59064765 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/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), diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index 33e953b6218..534e50e115f 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/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>(&a/int, &a/int) <: &fn<a,b>(&a/int, &b/int)? (No) + 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) 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 -`fn(&a/T)` (this is case #3, above). Bad. +the return value has type `fn<b>(&'b T)` when it really has type +`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 diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index d692a66f699..fe77b62de43 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/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) - -> &v/mut ValsAndBindings<Self, T>; + static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + -> &'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) - -> &v/mut ValsAndBindings<ty::TyVid, Bounds<ty::t>> { + static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + -> &'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) - -> &v/mut ValsAndBindings<ty::IntVid, Option<IntVarValue>> { + static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + -> &'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) - -> &v/mut ValsAndBindings<ty::FloatVid, Option<ast::float_ty>> { + static fn appropriate_vals_and_bindings(&self, infcx: &'v mut InferCtxt) + -> &'v mut ValsAndBindings<ty::FloatVid, Option<ast::float_ty>> { return &mut infcx.float_var_bindings; } } diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs index bd2f641c017..5a08884777c 100644 --- a/src/libstd/arc.rs +++ b/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, - cond: &self/sync::Condvar/&self + failed: &'self mut bool, + 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, diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs index 6b5f806f7df..68132a1c08d 100644 --- a/src/libstd/arena.rs +++ b/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) diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs index 0bd9e1eac51..56ce54be44e 100644 --- a/src/libstd/base64.rs +++ b/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() } diff --git a/src/libstd/bigint.rs b/src/libstd/bigint.rs index 5c3f37faca7..e128859bb7d 100644 --- a/src/libstd/bigint.rs +++ b/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], - &static/[BigDigit], - &static/[BigDigit])] = &[ + const sum_triples: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[ (&[], &[], &[]), (&[], &[ 1], &[ 1]), (&[ 1], &[ 1], &[ 2]), @@ -1085,9 +1085,9 @@ mod biguint_tests { } } - const mul_triples: &static/[(&static/[BigDigit], - &static/[BigDigit], - &static/[BigDigit])] = &[ + const mul_triples: &'static [(&'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], - &static/[BigDigit], - &static/[BigDigit], - &static/[BigDigit])] + const divmod_quadruples: &'static [(&'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], - &static/[BigDigit], - &static/[BigDigit])] = &[ + const sum_triples: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[ (&[], &[], &[]), (&[], &[ 1], &[ 1]), (&[ 1], &[ 1], &[ 2]), @@ -1451,9 +1451,9 @@ mod bigint_tests { } } - const mul_triples: &static/[(&static/[BigDigit], - &static/[BigDigit], - &static/[BigDigit])] = &[ + const mul_triples: &'static [(&'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], - &static/[BigDigit], - &static/[BigDigit], - &static/[BigDigit])] + const divmod_quadruples: &'static [(&'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit], + &'static [BigDigit])] = &[ (&[ 1], &[ 2], &[], &[1]), (&[ 1, 1], &[ 2], &[-1/2+1], &[1]), diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs index 15131093acb..90269e28b8a 100644 --- a/src/libstd/deque.rs +++ b/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!() } } diff --git a/src/libstd/future.rs b/src/libstd/future.rs index 5dc264cb878..4867204ea39 100644 --- a/src/libstd/future.rs +++ b/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 diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 56f2611c914..e52d08c40fe 100644 --- a/src/libstd/json.rs +++ b/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() } diff --git a/src/libstd/priority_queue.rs b/src/libstd/priority_queue.rs index 99d19c4839c..b9b5075c434 100644 --- a/src/libstd/priority_queue.rs +++ b/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()) } } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index 0288155d29e..2c927b5db16 100644 --- a/src/libstd/serialize.rs +++ b/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| { diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs index bdce257e347..c63ef9b7258 100644 --- a/src/libstd/smallintmap.rs +++ b/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") } } diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs index e0828d981d7..43c68196eb8 100644 --- a/src/libstd/sort.rs +++ b/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 } } diff --git a/src/libstd/stats.rs b/src/libstd/stats.rs index 2a62ebadd2b..cecf9686327 100644 --- a/src/libstd/stats.rs +++ b/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) } diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index 1d1ec0e11f7..d556be6b85b 100644 --- a/src/libstd/sync.rs +++ b/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 { diff --git a/src/libstd/test.rs b/src/libstd/test.rs index cec9f56708f..63cf4c998df 100644 --- a/src/libstd/test.rs +++ b/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 { diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs index 8e204014975..7192da7b88e 100644 --- a/src/libstd/treemap.rs +++ b/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> { - let mut current: &self/Option<~TreeNode<K, V>> = &self.root; + pure fn find(&self, key: &K) -> Option<&'self V> { + 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 node: &self/Option<~TreeNode<K, V>> + priv stack: ~[&'self ~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>>, - f: &fn(&(&r/K, &r/V)) -> bool) { +pure fn each<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, + 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>>, - f: &fn(&(&r/K, &r/V)) -> bool) { +pure fn each_reverse<K: TotalOrd, V>(node: &'r Option<~TreeNode<K, V>>, + 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) } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index f0822ea4d25..652bc541a1f 100644 --- a/src/libsyntax/ext/base.rs +++ b/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 diff --git a/src/libsyntax/ext/deriving.rs b/src/libsyntax/ext/deriving.rs index 26b5b4566b7..54b123bff2f 100644 --- a/src/libsyntax/ext/deriving.rs +++ b/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, diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs index 6deffbe0ae1..2cf52c47959 100644 --- a/src/libsyntax/ext/quote.rs +++ b/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"]), diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs index ba0c7a71b7c..dbabca55a11 100644 --- a/src/libsyntax/opt_vec.rs +++ b/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] diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index a30b910b347..7b7d246c324 100644 --- a/src/libsyntax/parse/parser.rs +++ b/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(© *self.token) { diff --git a/src/test/auxiliary/cci_const.rs b/src/test/auxiliary/cci_const.rs index b2dd0cc8e58..945004ede6d 100644 --- a/src/test/auxiliary/cci_const.rs +++ b/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; diff --git a/src/test/compile-fail/borrowck-addr-of-upvar.rs b/src/test/compile-fail/borrowck-addr-of-upvar.rs index 4e8af4f0421..640bc887731 100644 --- a/src/test/compile-fail/borrowck-addr-of-upvar.rs +++ b/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 { - let result: @fn() -> &static/int = || &*x; //~ ERROR illegal borrow +fn foo(x: @int) -> @fn() -> &'static int { + let result: @fn() -> &'static int = || &*x; //~ ERROR illegal borrow result } diff --git a/src/test/compile-fail/const-cast-different-types.rs b/src/test/compile-fail/const-cast-different-types.rs index 08fa6915106..45e39b47d23 100644 --- a/src/test/compile-fail/const-cast-different-types.rs +++ b/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 diff --git a/src/test/compile-fail/issue-2149.rs b/src/test/compile-fail/issue-2149.rs index def1fa30f3b..da3728ff3ae 100644 --- a/src/test/compile-fail/issue-2149.rs +++ b/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 } diff --git a/src/test/compile-fail/issue-2478.rs b/src/test/compile-fail/issue-2478.rs index 5bde7c67935..2b52cab7fe7 100644 --- a/src/test/compile-fail/issue-2478.rs +++ b/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; diff --git a/src/test/compile-fail/issue-3243.rs b/src/test/compile-fail/issue-3243.rs index 443fae619ba..f235c4bc97c 100644 --- a/src/test/compile-fail/issue-3243.rs +++ b/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 } diff --git a/src/test/compile-fail/issue-3311.rs b/src/test/compile-fail/issue-3311.rs index 8872357a8d4..1b83cefbf33 100644 --- a/src/test/compile-fail/issue-3311.rs +++ b/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 } } diff --git a/src/test/compile-fail/issue-3563.rs b/src/test/compile-fail/issue-3563.rs index 9f7a0745c3b..0388f0fd290 100644 --- a/src/test/compile-fail/issue-3563.rs +++ b/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() {} diff --git a/src/test/compile-fail/issue-3888.rs b/src/test/compile-fail/issue-3888.rs index 779265e5a29..482d1e9fe8a 100644 --- a/src/test/compile-fail/issue-3888.rs +++ b/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 { diff --git a/src/test/compile-fail/issue-4335.rs b/src/test/compile-fail/issue-4335.rs index 7242d993f33..ae147e628e4 100644 --- a/src/test/compile-fail/issue-4335.rs +++ b/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; diff --git a/src/test/compile-fail/issue-4523.rs b/src/test/compile-fail/issue-4523.rs index 6045ac6cba3..e8e27029371 100644 --- a/src/test/compile-fail/issue-4523.rs +++ b/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(); diff --git a/src/test/compile-fail/kindck-owned-trait-contains.rs b/src/test/compile-fail/kindck-owned-trait-contains.rs index 305f4bd6bef..dadc66b5029 100644 --- a/src/test/compile-fail/kindck-owned-trait-contains.rs +++ b/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 diff --git a/src/test/compile-fail/kindck-owned-trait-scoped.rs b/src/test/compile-fail/kindck-owned-trait-scoped.rs index 0ccc5ac8bf0..63690f03093 100644 --- a/src/test/compile-fail/kindck-owned-trait-scoped.rs +++ b/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; diff --git a/src/test/compile-fail/regions-addr-of-self.rs b/src/test/compile-fail/regions-addr-of-self.rs index 96657edb5b1..732d946bf9e 100644 --- a/src/test/compile-fail/regions-addr-of-self.rs +++ b/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; } } diff --git a/src/test/compile-fail/regions-blk.rs b/src/test/compile-fail/regions-blk.rs index 9b1895ba4bd..893e4c41178 100644 --- a/src/test/compile-fail/regions-blk.rs +++ b/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; } } diff --git a/src/test/compile-fail/regions-fn-bound.rs b/src/test/compile-fail/regions-fn-bound.rs index 6deef8cee9e..df078bbb54b 100644 --- a/src/test/compile-fail/regions-fn-bound.rs +++ b/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 diff --git a/src/test/compile-fail/regions-fn-subtyping.rs b/src/test/compile-fail/regions-fn-subtyping.rs index 50674ac81fe..a90b3d0f429 100644 --- a/src/test/compile-fail/regions-fn-subtyping.rs +++ b/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)>( - of::<&fn(&a/T)>()); + subtype::<&fn(&'a T)>( + of::<&fn(&'a T)>()); - subtype::<&fn(&a/T)>( - of::<&fn(&b/T)>()); + subtype::<&fn(&'a T)>( + of::<&fn(&'b T)>()); - subtype::<&fn(&b/T)>( - of::<&fn(&x/T)>()); + subtype::<&fn(&'b T)>( + of::<&fn(&'x T)>()); - subtype::<&fn(&x/T)>( - of::<&fn(&b/T)>()); //~ ERROR mismatched types + subtype::<&fn(&'x T)>( + of::<&fn(&'b T)>()); //~ ERROR mismatched types - subtype::<&fn(&a/T, &b/T)>( - of::<&fn(&a/T, &a/T)>()); + subtype::<&fn(&'a T, &'b T)>( + of::<&fn(&'a T, &'a T)>()); - subtype::<&fn(&a/T, &a/T)>( - of::<&fn(&a/T, &b/T)>()); //~ ERROR mismatched types + subtype::<&fn(&'a T, &'a T)>( + of::<&fn(&'a T, &'b T)>()); //~ ERROR mismatched types - subtype::<&fn(&a/T, &b/T)>( - of::<&fn(&x/T, &y/T)>()); + subtype::<&fn(&'a T, &'b T)>( + of::<&fn(&'x T, &'y T)>()); - subtype::<&fn(&x/T, &y/T)>( - of::<&fn(&a/T, &b/T)>()); //~ ERROR mismatched types + subtype::<&fn(&'x T, &'y T)>( + of::<&fn(&'a T, &'b T)>()); //~ ERROR mismatched types - subtype::<&fn(&x/T) -> @fn(&a/T)>( - of::<&fn(&x/T) -> @fn(&a/T)>()); + subtype::<&fn(&'x T) -> @fn(&'a T)>( + of::<&fn(&'x T) -> @fn(&'a T)>()); - subtype::<&fn(&a/T) -> @fn(&a/T)>( - of::<&fn(&a/T) -> @fn(&b/T)>()); //~ ERROR mismatched types + subtype::<&fn(&'a T) -> @fn(&'a T)>( + of::<&fn(&'a T) -> @fn(&'b T)>()); //~ ERROR mismatched types - subtype::<&fn(&a/T) -> @fn(&a/T)>( - of::<&fn(&x/T) -> @fn(&b/T)>()); //~ ERROR mismatched types + subtype::<&fn(&'a T) -> @fn(&'a T)>( + of::<&fn(&'x T) -> @fn(&'b T)>()); //~ ERROR mismatched types - subtype::<&fn(&a/T) -> @fn(&b/T)>( - of::<&fn(&a/T) -> @fn(&a/T)>()); + subtype::<&fn(&'a T) -> @fn(&'b T)>( + of::<&fn(&'a T) -> @fn(&'a T)>()); } fn main() {} diff --git a/src/test/compile-fail/regions-fns.rs b/src/test/compile-fail/regions-fns.rs index a4f1825fcae..50eba71ac56 100644 --- a/src/test/compile-fail/regions-fns.rs +++ b/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) { - let mut g: @fn(x: &uint) = |x: &b/uint| {}; +fn not_ok(a: &uint, b: &'b uint) { + let mut g: @fn(x: &uint) = |x: &'b uint| {}; //~^ ERROR mismatched types g(a); } diff --git a/src/test/compile-fail/regions-freevar.rs b/src/test/compile-fail/regions-freevar.rs index 6545892d0bb..f89c5eaa9c1 100644 --- a/src/test/compile-fail/regions-freevar.rs +++ b/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; diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs index 82d75bcf5db..6402982a9e1 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs +++ b/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; } diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs index ef8f6748d36..c873e2519bd 100644 --- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs +++ b/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: ∫ diff --git a/src/test/compile-fail/regions-infer-call-3.rs b/src/test/compile-fail/regions-infer-call-3.rs index 49d3f6aee65..a3bc55228d8 100644 --- a/src/test/compile-fail/regions-infer-call-3.rs +++ b/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 diff --git a/src/test/compile-fail/regions-infer-contravariance-due-to-ret.rs b/src/test/compile-fail/regions-infer-contravariance-due-to-ret.rs index 936aa79d032..d93713f3f23 100644 --- a/src/test/compile-fail/regions-infer-contravariance-due-to-ret.rs +++ b/src/test/compile-fail/regions-infer-contravariance-due-to-ret.rs @@ -14,7 +14,7 @@ // the normal case. struct contravariant { - f: @fn() -> &self/int + f: @fn() -> &'self int } fn to_same_lifetime(bi: contravariant/&r) { diff --git a/src/test/compile-fail/regions-infer-covariance-due-to-arg.rs b/src/test/compile-fail/regions-infer-covariance-due-to-arg.rs index 27e1452d957..c527cdf233d 100644 --- a/src/test/compile-fail/regions-infer-covariance-due-to-arg.rs +++ b/src/test/compile-fail/regions-infer-covariance-due-to-arg.rs @@ -13,7 +13,7 @@ // You can upcast to a *larger region* but not a smaller one. struct covariant { - f: @fn(x: &self/int) -> int + f: @fn(x: &'self int) -> int } fn to_same_lifetime(bi: covariant/&r) { diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs index c84afc6ca64..15b39d772f0 100644 --- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs +++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs @@ -9,7 +9,7 @@ // except according to those terms. struct invariant { - f: @fn(x: @mut &self/int) + f: @fn(x: @mut &'self int) } fn to_same_lifetime(bi: invariant/&r) { diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs index b958aa70aa4..ff2b4246f01 100644 --- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs +++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs @@ -9,7 +9,7 @@ // except according to those terms. struct invariant { - f: @fn() -> @mut &self/int + f: @fn() -> @mut &'self int } fn to_same_lifetime(bi: invariant/&r) { diff --git a/src/test/compile-fail/regions-infer-paramd-indirect.rs b/src/test/compile-fail/regions-infer-paramd-indirect.rs index 99a3cc0ab6f..e4ad93bde17 100644 --- a/src/test/compile-fail/regions-infer-paramd-indirect.rs +++ b/src/test/compile-fail/regions-infer-paramd-indirect.rs @@ -29,7 +29,7 @@ impl<'self> set_f for c<'self> { } fn set_f_bad(&self, b: @b) { - self.f = b; //~ ERROR mismatched types: expected `@@&self/int` but found `@@&int` + self.f = b; //~ ERROR mismatched types: expected `@@&'self int` but found `@@&int` } } diff --git a/src/test/compile-fail/regions-nested-fns-2.rs b/src/test/compile-fail/regions-nested-fns-2.rs index b4cbbacea3f..26d6bbd5303 100644 --- a/src/test/compile-fail/regions-nested-fns-2.rs +++ b/src/test/compile-fail/regions-nested-fns-2.rs @@ -12,7 +12,7 @@ fn ignore<T>(_t: T) {} fn nested() { let y = 3; - ignore(|z: &z/int| -> &z/int { + ignore(|z: &'z int| -> &'z int { if false { &y } else { z } //~ ERROR illegal borrow }); } diff --git a/src/test/compile-fail/regions-nested-fns.rs b/src/test/compile-fail/regions-nested-fns.rs index 714b863ca1d..6ef37efeb41 100644 --- a/src/test/compile-fail/regions-nested-fns.rs +++ b/src/test/compile-fail/regions-nested-fns.rs @@ -10,17 +10,17 @@ fn ignore<T>(t: T) {} -fn nested(x: &x/int) { +fn nested(x: &'x int) { let y = 3; let mut ay = &y; //~ ERROR cannot infer an appropriate lifetime - ignore(|z: &z/int| { + ignore(|z: &'z int| { ay = x; ay = &y; //~ ERROR cannot infer an appropriate lifetime ay = z; }); - ignore(|z: &z/int| -> &z/int { + ignore(|z: &'z int| -> &'z int { if false { return x; } //~ ERROR mismatched types if false { return ay; } return z; diff --git a/src/test/compile-fail/regions-out-of-scope-slice.rs b/src/test/compile-fail/regions-out-of-scope-slice.rs index 102ff8b3998..b3db225700a 100644 --- a/src/test/compile-fail/regions-out-of-scope-slice.rs +++ b/src/test/compile-fail/regions-out-of-scope-slice.rs @@ -15,7 +15,7 @@ fn foo(cond: bool) { let mut x; //~ ERROR foo if cond { - x = &blk/[1,2,3]; + x = &'blk [1,2,3]; } } diff --git a/src/test/compile-fail/regions-ret-borrowed-1.rs b/src/test/compile-fail/regions-ret-borrowed-1.rs index ab6a37b58de..7218dcf379b 100644 --- a/src/test/compile-fail/regions-ret-borrowed-1.rs +++ b/src/test/compile-fail/regions-ret-borrowed-1.rs @@ -12,11 +12,11 @@ // some point regions-ret-borrowed reported an error but this file did // not, due to special hardcoding around the anonymous region. -fn with<R>(f: &fn(x: &a/int) -> R) -> R { +fn with<R>(f: &fn(x: &'a int) -> R) -> R { f(&3) } -fn return_it() -> &a/int { +fn return_it() -> &'a int { with(|o| o) //~ ERROR mismatched types //~^ ERROR reference is not valid outside of its lifetime } diff --git a/src/test/compile-fail/regions-ret.rs b/src/test/compile-fail/regions-ret.rs index d43065e12fb..cecd847843c 100644 --- a/src/test/compile-fail/regions-ret.rs +++ b/src/test/compile-fail/regions-ret.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f(_x : &a/int) -> &a/int { +fn f(_x : &'a int) -> &'a int { return &3; //~ ERROR illegal borrow } diff --git a/src/test/compile-fail/regions-scoping.rs b/src/test/compile-fail/regions-scoping.rs index e675d4d455f..f0c81d16b03 100644 --- a/src/test/compile-fail/regions-scoping.rs +++ b/src/test/compile-fail/regions-scoping.rs @@ -17,7 +17,7 @@ fn nested<'x>(x: &'x int) { // (1) z: &fn<'z>(x: &'x int, // Refers to `x` at (1) y: &'y int, // Refers to `y` at (2) z: &'z int) -> &'z int| // A fresh region `z` (3) - -> &x/int { + -> &'x int { if false { return z(x, y, x); } if false { return z(x, y, y); } @@ -40,9 +40,9 @@ fn nested<'x>(x: &'x int) { // (1) // anymore but rather borrowck. Therefore, it doesn't end up // getting printed out since compilation fails after typeck. // - // let f: &x/int = foo(&z, &z, |_x, _y, z| z ); // ERROR mismatched types: expected `&x/int` but found + // let f: &'x int = foo(&z, &z, |_x, _y, z| z ); // ERROR mismatched types: expected `&'x int` but found - foo(x, &z, |x, _y, _z| x); //~ ERROR mismatched types: expected `&z/int` but found `&x/int` + foo(x, &z, |x, _y, _z| x); //~ ERROR mismatched types: expected `&'z int` but found `&'x int` // Note: originally I had foo(x, &z, ...) here, but in that // case the region inferencer deduced that this was valid if diff --git a/src/test/compile-fail/regions-trait-2.rs b/src/test/compile-fail/regions-trait-2.rs index bbaed2ab600..5811496cab4 100644 --- a/src/test/compile-fail/regions-trait-2.rs +++ b/src/test/compile-fail/regions-trait-2.rs @@ -17,7 +17,7 @@ trait get_ctxt { struct has_ctxt<'self> { c: &'self ctxt } impl<'self> get_ctxt for has_ctxt<'self> { - fn get_ctxt(&self) -> &self/ctxt { self.c } + fn get_ctxt(&self) -> &'self ctxt { self.c } } fn make_gc() -> @get_ctxt { diff --git a/src/test/compile-fail/regions-trait-3.rs b/src/test/compile-fail/regions-trait-3.rs index 10b7b1058d8..e947dbf9308 100644 --- a/src/test/compile-fail/regions-trait-3.rs +++ b/src/test/compile-fail/regions-trait-3.rs @@ -12,7 +12,7 @@ // except according to those terms. trait get_ctxt { - fn get_ctxt(self) -> &self/uint; + fn get_ctxt(self) -> &'self uint; } fn make_gc1(gc: @get_ctxt/&a) -> @get_ctxt/&b { diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index 16cd51c8f27..78bdee1430c 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -16,7 +16,7 @@ trait iterable<A> { fn iterate(&self, blk: &fn(x: &A) -> bool); } -impl<A> iterable<A> for &self/[A] { +impl<A> iterable<A> for &'self [A] { fn iterate(&self, f: &fn(x: &A) -> bool) { for vec::each(*self) |e| { if !f(e) { break; } diff --git a/src/test/run-pass/bare-static-string.rs b/src/test/run-pass/bare-static-string.rs index ceae1392d3b..d8015f0b92c 100644 --- a/src/test/run-pass/bare-static-string.rs +++ b/src/test/run-pass/bare-static-string.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x: &static/str = "foo"; + let x: &'static str = "foo"; io::println(x); } diff --git a/src/test/run-pass/borrowck-root-while-cond.rs b/src/test/run-pass/borrowck-root-while-cond.rs index 285796db20e..a8823c477aa 100644 --- a/src/test/run-pass/borrowck-root-while-cond.rs +++ b/src/test/run-pass/borrowck-root-while-cond.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} struct Rec { f: @int } diff --git a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs index d8612155f6c..0699df703c6 100644 --- a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs +++ b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm-3.rs @@ -1,5 +1,5 @@ struct Wizard { - spells: ~[&static/str] + spells: ~[&'static str] } pub impl Wizard { diff --git a/src/test/run-pass/borrowed-ptr-pattern-3.rs b/src/test/run-pass/borrowed-ptr-pattern-3.rs index 9043018b816..1e9175ac196 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-3.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-3.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(s: &r/uint) -> bool { +fn foo(s: &'r uint) -> bool { match s { &3 => true, _ => false diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs index d0d276a8c8c..42c0795b3dd 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-option.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn select(x: &r/Option<int>, y: &r/Option<int>) -> &r/Option<int> { +fn select(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> { match (x, y) { (&None, &None) => x, (&Some(_), _) => x, diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs index dca68b4c2a3..64c6f368f2b 100644 --- a/src/test/run-pass/const-cast.rs +++ b/src/test/run-pass/const-cast.rs @@ -12,7 +12,7 @@ extern fn foo() {} const x: *u8 = foo; const y: *libc::c_void = x as *libc::c_void; -const a: &static/int = &10; +const a: &'static int = &10; const b: *int = a as *int; fn main() { diff --git a/src/test/run-pass/const-cross-crate-const.rs b/src/test/run-pass/const-cross-crate-const.rs index a7c30593ecb..e01519ae8a5 100644 --- a/src/test/run-pass/const-cross-crate-const.rs +++ b/src/test/run-pass/const-cross-crate-const.rs @@ -12,7 +12,7 @@ // aux-build:cci_const.rs extern mod cci_const; -const foo: &static/str = cci_const::foopy; +const foo: &'static str = cci_const::foopy; const a: uint = cci_const::uint_val; const b: uint = cci_const::uint_expr + 5; diff --git a/src/test/run-pass/const-enum-ptr.rs b/src/test/run-pass/const-enum-ptr.rs index 6004f9b9001..594350d2988 100644 --- a/src/test/run-pass/const-enum-ptr.rs +++ b/src/test/run-pass/const-enum-ptr.rs @@ -9,7 +9,7 @@ // except according to those terms. enum E { V0, V1(int) } -const C: &static/E = &V0; +const C: &'static E = &V0; pub fn main() { match *C { diff --git a/src/test/run-pass/const-enum-vec-ptr.rs b/src/test/run-pass/const-enum-vec-ptr.rs index c4017b549e6..b398bfbf0d5 100644 --- a/src/test/run-pass/const-enum-vec-ptr.rs +++ b/src/test/run-pass/const-enum-vec-ptr.rs @@ -9,7 +9,7 @@ // except according to those terms. enum E { V1(int), V0 } -const C: &static/[E] = &[V0, V1(0xDEADBEE), V0]; +const C: &'static [E] = &[V0, V1(0xDEADBEE), V0]; pub fn main() { match C[1] { diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index d0773a73923..a1637f6ebb8 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -9,7 +9,7 @@ // except according to those terms. const a: [u8 * 3] = ['h' as u8, 'i' as u8, 0 as u8]; -const c: &static/[u8 * 3] = &a; +const c: &'static [u8 * 3] = &a; const b: *u8 = c as *u8; fn main() { diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs index 44edbd44bd3..1a21fa0a5d7 100644 --- a/src/test/run-pass/explicit-self.rs +++ b/src/test/run-pass/explicit-self.rs @@ -29,13 +29,13 @@ fn compute_area(shape: &shape) -> float { pub impl shape { // self is in the implicit self region fn select<T>(&self, threshold: float, - a: &r/T, b: &r/T) -> &r/T { + a: &'r T, b: &'r T) -> &'r T { if compute_area(self) > threshold {a} else {b} } } fn select_based_on_unit_circle<T>( - threshold: float, a: &r/T, b: &r/T) -> &r/T { + threshold: float, a: &'r T, b: &'r T) -> &'r T { let shape = &circle(Point{x: 0.0, y: 0.0}, 1.0); shape.select(threshold, a, b) @@ -58,7 +58,7 @@ pub impl thing { fn foo(@self) -> int { *self.x.a } fn bar(~self) -> int { *self.x.a } fn quux(&self) -> int { *self.x.a } - fn baz(&self) -> &self/A { &self.x } + fn baz(&self) -> &'self A { &self.x } fn spam(self) -> int { *self.x.a } } diff --git a/src/test/run-pass/issue-2502.rs b/src/test/run-pass/issue-2502.rs index 9af41e48aa2..cfae757aee8 100644 --- a/src/test/run-pass/issue-2502.rs +++ b/src/test/run-pass/issue-2502.rs @@ -13,12 +13,12 @@ struct font { } pub impl font/&self { - fn buf(&self) -> &self/~[u8] { + fn buf(&self) -> &'self ~[u8] { self.fontbuf } } -fn font(fontbuf: &r/~[u8]) -> font/&r { +fn font(fontbuf: &'r ~[u8]) -> font/&r { font { fontbuf: fontbuf } diff --git a/src/test/run-pass/issue-2748-b.rs b/src/test/run-pass/issue-2748-b.rs index 7e5730a3db1..62016abf74b 100644 --- a/src/test/run-pass/issue-2748-b.rs +++ b/src/test/run-pass/issue-2748-b.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn thing(x: &r/[int]) -> &r/[int] { x } +fn thing(x: &'r [int]) -> &'r [int] { x } pub fn main() { let x = &[1,2,3]; let y = x; diff --git a/src/test/run-pass/issue-3860.rs b/src/test/run-pass/issue-3860.rs index b113e902963..18839fa3c7f 100644 --- a/src/test/run-pass/issue-3860.rs +++ b/src/test/run-pass/issue-3860.rs @@ -11,7 +11,7 @@ struct Foo { x: int } pub impl Foo { - fn stuff(&mut self) -> &self/mut Foo { + fn stuff(&mut self) -> &'self mut Foo { return self; } } diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs index 06e652cc7cd..38aeab0888c 100644 --- a/src/test/run-pass/issue-3888-2.rs +++ b/src/test/run-pass/issue-3888-2.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn vec_peek<T>(v: &r/[T]) -> &r/[T] { +fn vec_peek<T>(v: &'r [T]) -> &'r [T] { // This doesn't work, and should. // v.slice(1, 5) vec::slice(v, 1, 5) diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs index 80cc9a72c33..0a9c731e9b8 100644 --- a/src/test/run-pass/issue-4448.rs +++ b/src/test/run-pass/issue-4448.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let (port, chan) = comm::stream::<&static/str>(); + let (port, chan) = comm::stream::<&'static str>(); do task::spawn { fail_unless!(port.recv() == "hello, world"); diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs index 9f093812d8a..8e363c3d5db 100644 --- a/src/test/run-pass/reflect-visit-data.rs +++ b/src/test/run-pass/reflect-visit-data.rs @@ -201,9 +201,9 @@ impl<V:TyVisitor + movable_ptr> TyVisitor for ptr_visit_adaptor<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 } @@ -238,9 +238,9 @@ impl<V:TyVisitor + movable_ptr> TyVisitor for ptr_visit_adaptor<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 } @@ -276,9 +276,9 @@ impl<V:TyVisitor + movable_ptr> TyVisitor for ptr_visit_adaptor<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 } @@ -439,9 +439,9 @@ impl<V:TyVisitor + movable_ptr> TyVisitor for ptr_visit_adaptor<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 } diff --git a/src/test/run-pass/region-dependent-addr-of.rs b/src/test/run-pass/region-dependent-addr-of.rs index a3f5c41e1ac..6cad8c74592 100644 --- a/src/test/run-pass/region-dependent-addr-of.rs +++ b/src/test/run-pass/region-dependent-addr-of.rs @@ -25,54 +25,54 @@ struct C { f: int } -fn get_v1(a: &v/A) -> &v/int { +fn get_v1(a: &'v A) -> &'v int { // Region inferencer must deduce that &v < L2 < L1 let foo = &a.value; // L1 &foo.v1 // L2 } -fn get_v2(a: &v/A, i: uint) -> &v/int { +fn get_v2(a: &'v A, i: uint) -> &'v int { let foo = &a.value; &foo.v2[i] } -fn get_v3(a: &v/A, i: uint) -> &v/int { +fn get_v3(a: &'v A, i: uint) -> &'v int { let foo = &a.value; &foo.v3[i] } -fn get_v4(a: &v/A, i: uint) -> &v/int { +fn get_v4(a: &'v A, i: uint) -> &'v int { let foo = &a.value; &foo.v4.f } -fn get_v5(a: &v/A, i: uint) -> &v/int { +fn get_v5(a: &'v A, i: uint) -> &'v int { let foo = &a.value; &foo.v5.f } -fn get_v6_a(a: &v/A, i: uint) -> &v/int { +fn get_v6_a(a: &'v A, i: uint) -> &'v int { match a.value.v6 { Some(ref v) => &v.f, None => fail!() } } -fn get_v6_b(a: &v/A, i: uint) -> &v/int { +fn get_v6_b(a: &'v A, i: uint) -> &'v int { match *a { A { value: B { v6: Some(ref v), _ } } => &v.f, _ => fail!() } } -fn get_v6_c(a: &v/A, i: uint) -> &v/int { +fn get_v6_c(a: &'v A, i: uint) -> &'v int { match a { &A { value: B { v6: Some(ref v), _ } } => &v.f, _ => fail!() } } -fn get_v5_ref(a: &v/A, i: uint) -> &v/int { +fn get_v5_ref(a: &'v A, i: uint) -> &'v int { match &a.value { &B {v5: ~C {f: ref v}, _} => v } diff --git a/src/test/run-pass/region-return-interior-of-option.rs b/src/test/run-pass/region-return-interior-of-option.rs index 59dbbde7b77..ced2948545f 100644 --- a/src/test/run-pass/region-return-interior-of-option.rs +++ b/src/test/run-pass/region-return-interior-of-option.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn get<T>(opt: &r/Option<T>) -> &r/T { +fn get<T>(opt: &'r Option<T>) -> &'r T { match *opt { Some(ref v) => v, None => fail!(~"none") diff --git a/src/test/run-pass/regions-addr-of-ret.rs b/src/test/run-pass/regions-addr-of-ret.rs index 38e0ac02139..622a1eb9954 100644 --- a/src/test/run-pass/regions-addr-of-ret.rs +++ b/src/test/run-pass/regions-addr-of-ret.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f(x : &a/int) -> &a/int { +fn f(x : &'a int) -> &'a int { return &*x; } diff --git a/src/test/run-pass/regions-bot.rs b/src/test/run-pass/regions-bot.rs index 3be9d72c690..96ae71f0ff3 100644 --- a/src/test/run-pass/regions-bot.rs +++ b/src/test/run-pass/regions-bot.rs @@ -10,7 +10,7 @@ // A very limited test of the "bottom" region -fn produce_static<T>() -> &static/T { fail!(); } +fn produce_static<T>() -> &'static T { fail!(); } fn foo<T>(x: &T) -> &uint { produce_static() } diff --git a/src/test/run-pass/regions-equiv-fns.rs b/src/test/run-pass/regions-equiv-fns.rs index e78a6e69bdd..86b997a6008 100644 --- a/src/test/run-pass/regions-equiv-fns.rs +++ b/src/test/run-pass/regions-equiv-fns.rs @@ -13,7 +13,7 @@ fn ok(a: &uint) { // Here &r is an alias for &: - let mut g: @fn(x: &uint) = |x: &r/uint| {}; + let mut g: @fn(x: &uint) = |x: &'r uint| {}; g(a); } diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs index 6a03b4f910b..e38bd64da64 100644 --- a/src/test/run-pass/regions-escape-into-other-fn.rs +++ b/src/test/run-pass/regions-escape-into-other-fn.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn foo(x: &r/uint) -> &r/uint { x } +fn foo(x: &'r uint) -> &'r uint { x } fn bar(x: &uint) -> uint { *x } pub fn main() { diff --git a/src/test/run-pass/regions-fn-subtyping.rs b/src/test/run-pass/regions-fn-subtyping.rs index b28d8534fec..981eace6754 100644 --- a/src/test/run-pass/regions-fn-subtyping.rs +++ b/src/test/run-pass/regions-fn-subtyping.rs @@ -18,14 +18,14 @@ fn ok(f: @fn(x: &uint)) { // f's type should be a subtype of g's type), because f can be // used in any context that expects g's type. But this currently // fails. - let mut g: @fn(y: &r/uint) = |x: &r/uint| { }; + let mut g: @fn(y: &'r uint) = |x: &'r uint| { }; g = f; } // This version is the same as above, except that here, g's type is // inferred. fn ok_inferred(f: @fn(x: &uint)) { - let mut g: @fn(x: &r/uint) = |_| {}; + let mut g: @fn(x: &'r uint) = |_| {}; g = f; } diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs index e5e24a55843..5aff0274dc4 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-view.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn view<T>(x: &r/[T]) -> &r/[T] {x} +fn view<T>(x: &'r [T]) -> &'r [T] {x} pub fn main() { let v = ~[1, 2, 3]; diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index 69945a31f6d..fd48402dd10 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.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} pub fn main() { let x = @3; diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs index 9c4cb0d436d..b5dbf0fde5c 100644 --- a/src/test/run-pass/regions-infer-borrow-scope.rs +++ b/src/test/run-pass/regions-infer-borrow-scope.rs @@ -10,7 +10,7 @@ struct Point {x: int, y: int} -fn x_coord(p: &r/Point) -> &r/int { +fn x_coord(p: &'r Point) -> &'r int { return &p.x; } diff --git a/src/test/run-pass/regions-infer-call-2.rs b/src/test/run-pass/regions-infer-call-2.rs index dc38a7baacd..74c4c4260fc 100644 --- a/src/test/run-pass/regions-infer-call-2.rs +++ b/src/test/run-pass/regions-infer-call-2.rs @@ -14,7 +14,7 @@ fn with<T>(f: &fn(x: &int) -> T) -> T { f(&20) } -fn has_one(x: &a/int) -> int { +fn has_one(x: &'a int) -> int { do with |y| { takes_two(x, y) } } diff --git a/src/test/run-pass/regions-infer-call.rs b/src/test/run-pass/regions-infer-call.rs index 0477bd2d196..66baaf40108 100644 --- a/src/test/run-pass/regions-infer-call.rs +++ b/src/test/run-pass/regions-infer-call.rs @@ -10,7 +10,7 @@ fn takes_two(x: &int, y: &int) -> int { *x + *y } -fn has_two(x: &a/int, y: &b/int) -> int { +fn has_two(x: &'a int, y: &'b int) -> int { takes_two(x, y) } diff --git a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs index b1fa7287fdb..c45212eaa62 100644 --- a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs +++ b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs @@ -12,7 +12,7 @@ struct boxed_int { f: &'self int, } -fn max(bi: &r/boxed_int, f: &r/int) -> int { +fn max(bi: &'r boxed_int, f: &'r int) -> int { if *bi.f > *f {*bi.f} else {*f} } diff --git a/src/test/run-pass/regions-infer-contravariance.rs b/src/test/run-pass/regions-infer-contravariance.rs index 1c263a6f0c6..7d966b06e35 100644 --- a/src/test/run-pass/regions-infer-contravariance.rs +++ b/src/test/run-pass/regions-infer-contravariance.rs @@ -16,11 +16,11 @@ fn get(bi: &'r boxed_int<'r>) -> &'r int { bi.f } -fn with(bi: &r/boxed_int) { +fn with(bi: &'r boxed_int) { // Here, the upcast is allowed because the `boxed_int` type is // contravariant with respect to `&r`. See also // compile-fail/regions-infer-invariance-due-to-mutability.rs - let bi: &blk/boxed_int/&blk = bi; + let bi: &'blk boxed_int/&blk = bi; fail_unless!(*get(bi) == 22); } diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs index 0049653dea9..1066c5fd4ca 100644 --- a/src/test/run-pass/regions-params.rs +++ b/src/test/run-pass/regions-params.rs @@ -10,7 +10,7 @@ // xfail-fast -fn region_identity(x: &r/uint) -> &r/uint { x } +fn region_identity(x: &'r uint) -> &'r uint { x } fn apply<T>(t: T, f: &fn(T) -> T) -> T { f(t) } diff --git a/src/test/run-pass/regions-trait.rs b/src/test/run-pass/regions-trait.rs index 5ca4af37737..481f25745cd 100644 --- a/src/test/run-pass/regions-trait.rs +++ b/src/test/run-pass/regions-trait.rs @@ -11,13 +11,13 @@ struct Ctxt { v: uint } trait get_ctxt { - fn get_ctxt(&self) -> &self/Ctxt; + fn get_ctxt(&self) -> &'self Ctxt; } struct HasCtxt { c: &'self Ctxt } impl get_ctxt for HasCtxt<'self> { - fn get_ctxt(&self) -> &self/Ctxt { + fn get_ctxt(&self) -> &'self Ctxt { self.c } } |