Lifetime anchors for raw string conversion functions

Instead of obtaining the lifetime from a raw pointer,
provide it explicitly in the manner of rust-lang/rfcs#556.

src/error.rs

@@ -111,7 +111,7 @@ impl ErrorTrait for Error {
         let mut os: Option<&'a str> = None;
         let raw = unsafe { &*self.ptr };
         if !raw.message.is_null() {
-            os = unsafe { gstr::parse_as_utf8(&raw.message).ok() };
+            os = unsafe { gstr::parse_as_utf8(raw.message, self).ok() };
         }
         if os.is_none() {
             let domain = unsafe { Quark::new(raw.domain) };
@@ -128,9 +128,9 @@ impl ErrorTrait for Error {
 
     fn detail(&self) -> Option<String> {
         if !self.ptr.is_null() {
-            let msg = unsafe { &(*self.ptr).message };
+            let msg = unsafe { (*self.ptr).message };
             if !msg.is_null() {
-                let msg_bytes = unsafe { gstr::parse_as_bytes(msg) };
+                let msg_bytes = unsafe { gstr::parse_as_bytes(msg, self) };
                 return Some(String::from_utf8_lossy(msg_bytes).into_owned());
             }
         }

src/gstr.rs

@@ -34,22 +34,21 @@ pub struct GStr {
     ptr: *const gchar,
 }
 
-pub unsafe fn parse_as_bytes(raw: & *const gchar) -> &[u8] {
+pub unsafe fn parse_as_bytes<'a, T: ?Sized>(raw: *const gchar,
+                                            life_anchor: &'a T)
+                                           -> &'a [u8]
+{
     assert!(!raw.is_null());
-    let r = mem::copy_lifetime(raw, &(*raw as *const u8));
-    slice::from_raw_buf(r, libc::strlen(*raw) as uint)
+    let r = mem::copy_lifetime(life_anchor, &(raw as *const u8));
+    slice::from_raw_buf(r, libc::strlen(raw) as uint)
 }
 
 #[inline]
-pub unsafe fn parse_as_utf8(raw: & *const gchar)
-                           -> Result<&str, str::Utf8Error>
+pub unsafe fn parse_as_utf8<'a, T: ?Sized>(raw: *const gchar,
+                                           life_anchor: &'a T)
+                                          -> Result<&'a str, str::Utf8Error>
 {
-    str::from_utf8(parse_as_bytes(raw))
-}
-
-#[inline]
-pub unsafe fn parse_as_utf8_unchecked(raw: & *const gchar) -> &str {
-    str::from_utf8_unchecked(parse_as_bytes(raw))
+    str::from_utf8(parse_as_bytes(raw, life_anchor))
 }
 
 impl GStr {

src/gtype.rs

@@ -74,7 +74,7 @@ impl GType {
 impl fmt::Show for GType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = unsafe { ffi::g_type_name(self.to_raw()) };
-        match unsafe { gstr::parse_as_utf8(&name) } {
+        match unsafe { gstr::parse_as_utf8(name, "") } {
             Ok(s) => write!(f, "{}", s),
             Err(..) => Err(fmt::Error)
         }

src/quark.rs

@@ -20,7 +20,6 @@ use ffi;
 use gstr;
 use types::gchar;
 
-use std::mem;
 use std::str;
 use std::sync::atomic;
 
@@ -67,8 +66,7 @@ impl Quark {
         let Quark(raw) = *self;
         unsafe {
             let s = ffi::g_quark_to_string(raw);
-            let r = mem::copy_lifetime("", &s);
-            gstr::parse_as_bytes(r)
+            gstr::parse_as_bytes(s, "")
         }
     }
 

src/value.rs

@@ -163,8 +163,7 @@ impl Value {
             if s.is_null() {
                 return None;
             }
-            let r = mem::copy_lifetime(self, &s);
-            Some(gstr::parse_as_bytes(r))
+            Some(gstr::parse_as_bytes(s, self))
         }
     }