librustc: Implement arbitrary lifetimes in trait objects.

All trait objects must be annotated with a lifetime. This means that
code like this breaks:

    fn f(x: Box<Trait>) { ... }

    fn g<'a>(x: &'a Trait) { ... }

Change this code to:

    fn f(x: Box<Trait+'static>) { ... }

    fn g<'a>(x: &'a Trait<'a>) { ... }

This will be eventually addressed by some additions that @nikomatsakis
wants. However, the fundamental thrust of this change is necessary to
achieve memory safety. Further additions to improve ergonomics will
follow.

Closes rust-lang#5723.

Author: pcwalton

src/liballoc/boxed.rs

@@ -103,14 +103,14 @@ pub trait BoxAny {
 }
 
 #[stable]
-impl BoxAny for Box<Any> {
+impl<'a> BoxAny for Box<Any+'a> {
     #[inline]
-    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
+    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any+'a>> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
                 let to: TraitObject =
-                    *mem::transmute::<&Box<Any>, &TraitObject>(&self);
+                    *mem::transmute::<&Box<Any+'a>, &TraitObject>(&self);
 
                 // Prevent destructor on self being run
                 intrinsics::forget(self);
@@ -130,7 +130,7 @@ impl<T: fmt::Show> fmt::Show for Box<T> {
     }
 }
 
-impl fmt::Show for Box<Any> {
+impl<'a> fmt::Show for Box<Any+'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.pad("Box<Any>")
     }

src/liballoc/lib.rs

@@ -69,7 +69,7 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![no_std]
-#![feature(lang_items, phase, unsafe_destructor)]
+#![feature(lang_items, phase, unsafe_destructor, issue_5723_bootstrap)]
 
 #[phase(plugin, link)]
 extern crate core;

src/libcore/any.rs

@@ -132,7 +132,7 @@ pub trait AnyRefExt<'a> {
 }
 
 #[stable]
-impl<'a> AnyRefExt<'a> for &'a Any {
+impl<'a,'b> AnyRefExt<'a> for &'a Any+'b {
     #[inline]
     #[stable]
     fn is<T: 'static>(self) -> bool {
@@ -181,7 +181,7 @@ pub trait AnyMutRefExt<'a> {
 }
 
 #[stable]
-impl<'a> AnyMutRefExt<'a> for &'a mut Any {
+impl<'a,'b> AnyMutRefExt<'a> for &'a mut Any+'b {
     #[inline]
     #[unstable = "naming conventions around acquiring references may change"]
     fn downcast_mut<T: 'static>(self) -> Option<&'a mut T> {

src/libcore/fmt/mod.rs

@@ -81,7 +81,7 @@ pub trait FormatWriter {
 /// A struct to represent both where to emit formatting strings to and how they
 /// should be formatted. A mutable version of this is passed to all formatting
 /// traits.
-pub struct Formatter<'a> {
+pub struct Formatter<'a,'b> {
     /// Flags for formatting (packed version of rt::Flag)
     pub flags: uint,
     /// Character used as 'fill' whenever there is alignment
@@ -93,7 +93,7 @@ pub struct Formatter<'a> {
     /// Optionally specified precision for numeric types
     pub precision: Option<uint>,
 
-    buf: &'a mut FormatWriter,
+    buf: &'a mut FormatWriter+'b,
     curarg: slice::Items<'a, Argument<'a>>,
     args: &'a [Argument<'a>],
 }
@@ -281,7 +281,7 @@ pub fn write(output: &mut FormatWriter, args: &Arguments) -> Result {
     Ok(())
 }
 
-impl<'a> Formatter<'a> {
+impl<'a,'b> Formatter<'a,'b> {
 
     // First up is the collection of functions used to execute a format string
     // at runtime. This consumes all of the compile-time statics generated by
@@ -520,7 +520,7 @@ impl<'a, T: Show> Show for &'a T {
 impl<'a, T: Show> Show for &'a mut T {
     fn fmt(&self, f: &mut Formatter) -> Result { secret_show(&**self, f) }
 }
-impl<'a> Show for &'a Show {
+impl<'a,'b> Show for &'a Show+'b {
     fn fmt(&self, f: &mut Formatter) -> Result { (*self).fmt(f) }
 }
 
@@ -686,7 +686,7 @@ macro_rules! tuple (
 
 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
-impl<'a> Show for &'a any::Any {
+impl<'a,'b> Show for &'a any::Any+'b {
     fn fmt(&self, f: &mut Formatter) -> Result { f.pad("&Any") }
 }
 

src/libcore/lib.rs

@@ -58,7 +58,7 @@
 
 #![no_std]
 #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
-#![feature(simd, unsafe_destructor)]
+#![feature(simd, unsafe_destructor, issue_5723_bootstrap)]
 #![deny(missing_doc)]
 
 mod macros;

src/libdebug/lib.rs

@@ -25,7 +25,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 #![experimental]
-#![feature(managed_boxes, macro_rules)]
+#![feature(managed_boxes, macro_rules, issue_5723_bootstrap)]
 #![allow(experimental)]
 
 pub mod fmt;

src/libdebug/repr.rs

@@ -91,15 +91,15 @@ enum VariantState {
     AlreadyFound
 }
 
-pub struct ReprVisitor<'a> {
+pub struct ReprVisitor<'a,'b> {
     ptr: *const u8,
     ptr_stk: Vec<*const u8>,
     var_stk: Vec<VariantState>,
-    writer: &'a mut io::Writer,
+    writer: &'a mut io::Writer+'b,
     last_err: Option<io::IoError>,
 }
 
-impl<'a> MovePtr for ReprVisitor<'a> {
+impl<'a,'b> MovePtr for ReprVisitor<'a,'b> {
     #[inline]
     fn move_ptr(&mut self, adjustment: |*const u8| -> *const u8) {
         self.ptr = adjustment(self.ptr);
@@ -112,9 +112,10 @@ impl<'a> MovePtr for ReprVisitor<'a> {
     }
 }
 
-impl<'a> ReprVisitor<'a> {
+impl<'a,'b> ReprVisitor<'a,'b> {
     // Various helpers for the TyVisitor impl
-    pub fn new(ptr: *const u8, writer: &'a mut io::Writer) -> ReprVisitor<'a> {
+    pub fn new(ptr: *const u8, writer: &'a mut io::Writer+'b)
+               -> ReprVisitor<'a,'b> {
         ReprVisitor {
             ptr: ptr,
             ptr_stk: vec!(),
@@ -239,7 +240,7 @@ impl<'a> ReprVisitor<'a> {
     }
 }
 
-impl<'a> TyVisitor for ReprVisitor<'a> {
+impl<'a,'b> TyVisitor for ReprVisitor<'a,'b> {
     fn visit_bot(&mut self) -> bool {
         try!(self, self.writer.write("!".as_bytes()));
         true

src/libfourcc/lib.rs

@@ -71,7 +71,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
 }
 
 pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-                         -> Box<base::MacResult> {
+                         -> Box<base::MacResult+'static> {
     let (expr, endian) = parse_tts(cx, tts);
 
     let little = match endian {

src/libgreen/basic.rs

@@ -23,16 +23,16 @@ use std::rt::rtio::{PausableIdleCallback, Callback};
 use std::rt::exclusive::Exclusive;
 
 /// This is the only exported function from this module.
-pub fn event_loop() -> Box<EventLoop + Send> {
-    box BasicLoop::new() as Box<EventLoop + Send>
+pub fn event_loop() -> Box<EventLoop + Send + 'static> {
+    box BasicLoop::new() as Box<EventLoop + Send + 'static>
 }
 
 struct BasicLoop {
     work: Vec<proc(): Send>,             // pending work
-    remotes: Vec<(uint, Box<Callback + Send>)>,
+    remotes: Vec<(uint, Box<Callback + Send + 'static>)>,
     next_remote: uint,
     messages: Arc<Exclusive<Vec<Message>>>,
-    idle: Option<Box<Callback + Send>>,
+    idle: Option<Box<Callback + Send + 'static>>,
     idle_active: Option<Arc<atomics::AtomicBool>>,
 }
 
@@ -132,22 +132,24 @@ impl EventLoop for BasicLoop {
     }
 
     // FIXME: Seems like a really weird requirement to have an event loop provide.
-    fn pausable_idle_callback(&mut self, cb: Box<Callback + Send>)
-                              -> Box<PausableIdleCallback + Send> {
+    fn pausable_idle_callback(&mut self, cb: Box<Callback + Send + 'static>)
+                              -> Box<PausableIdleCallback + Send + 'static> {
         rtassert!(self.idle.is_none());
         self.idle = Some(cb);
         let a = Arc::new(atomics::AtomicBool::new(true));
         self.idle_active = Some(a.clone());
-        box BasicPausable { active: a } as Box<PausableIdleCallback + Send>
+        box BasicPausable {
+            active: a,
+        } as Box<PausableIdleCallback + Send + 'static>
     }
 
-    fn remote_callback(&mut self, f: Box<Callback + Send>)
-                       -> Box<RemoteCallback + Send> {
+    fn remote_callback(&mut self, f: Box<Callback + Send + 'static>)
+                       -> Box<RemoteCallback + Send + 'static> {
         let id = self.next_remote;
         self.next_remote += 1;
         self.remotes.push((id, f));
         box BasicRemote::new(self.messages.clone(), id) as
-            Box<RemoteCallback + Send>
+            Box<RemoteCallback + Send + 'static>
     }
 
     fn io<'a>(&'a mut self) -> Option<&'a mut IoFactory> { None }

src/libgreen/lib.rs

@@ -299,7 +299,7 @@ macro_rules! green_start( ($f:ident) => (
 /// The return value is used as the process return code. 0 on success, 101 on
 /// error.
 pub fn start(argc: int, argv: *const *const u8,
-             event_loop_factory: fn() -> Box<rtio::EventLoop + Send>,
+             event_loop_factory: fn() -> Box<rtio::EventLoop+Send+'static>,
              main: proc():Send) -> int {
     rt::init(argc, argv);
     let mut main = Some(main);
@@ -320,7 +320,7 @@ pub fn start(argc: int, argv: *const *const u8,
 ///
 /// This function will not return until all schedulers in the associated pool
 /// have returned.
-pub fn run(event_loop_factory: fn() -> Box<rtio::EventLoop + Send>,
+pub fn run(event_loop_factory: fn() -> Box<rtio::EventLoop + Send + 'static>,
            main: proc():Send) -> int {
     // Create a scheduler pool and spawn the main task into this pool. We will
     // get notified over a channel when the main task exits.
@@ -351,7 +351,7 @@ pub struct PoolConfig {
     pub threads: uint,
     /// A factory function used to create new event loops. If this is not
     /// specified then the default event loop factory is used.
-    pub event_loop_factory: fn() -> Box<rtio::EventLoop + Send>,
+    pub event_loop_factory: fn() -> Box<rtio::EventLoop + Send + 'static>,
 }
 
 impl PoolConfig {
@@ -376,7 +376,7 @@ pub struct SchedPool {
     stack_pool: StackPool,
     deque_pool: deque::BufferPool<Box<task::GreenTask>>,
     sleepers: SleeperList,
-    factory: fn() -> Box<rtio::EventLoop + Send>,
+    factory: fn() -> Box<rtio::EventLoop + Send + 'static>,
     task_state: TaskState,
     tasks_done: Receiver<()>,
 }