Change std::ffi::c_str_to_bytes to get the pointer as is

The lifetime of the resulting reference is freely inferred as
per RFC PR rust-lang#556.

[breaking-change]

Author: mzabaluev

src/librustc_trans/back/write.rs

@@ -49,7 +49,7 @@ pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! {
         if cstr == ptr::null() {
             handler.fatal(&msg[]);
         } else {
-            let err = ffi::c_str_to_bytes(&cstr);
+            let err = ffi::c_str_to_bytes(cstr);
             let err = String::from_utf8_lossy(err.as_slice()).to_string();
             libc::free(cstr as *mut _);
             handler.fatal(&format!("{}: {}",
@@ -380,7 +380,7 @@ unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_vo
         }
 
         llvm::diagnostic::Optimization(opt) => {
-            let pass_name = str::from_utf8(ffi::c_str_to_bytes(&opt.pass_name))
+            let pass_name = str::from_utf8(ffi::c_str_to_bytes(opt.pass_name))
                                 .ok()
                                 .expect("got a non-UTF8 pass name from LLVM");
             let enabled = match cgcx.remark {

src/librustc_trans/trans/base.rs

@@ -3040,7 +3040,7 @@ fn internalize_symbols(cx: &SharedCrateContext, reachable: &HashSet<String>) {
                     continue
                 }
 
-                let name = ffi::c_str_to_bytes(&llvm::LLVMGetValueName(val))
+                let name = ffi::c_str_to_bytes(llvm::LLVMGetValueName(val))
                                .to_vec();
                 declared.insert(name);
             }
@@ -3057,7 +3057,7 @@ fn internalize_symbols(cx: &SharedCrateContext, reachable: &HashSet<String>) {
                     continue
                 }
 
-                let name = ffi::c_str_to_bytes(&llvm::LLVMGetValueName(val))
+                let name = ffi::c_str_to_bytes(llvm::LLVMGetValueName(val))
                                .to_vec();
                 if !declared.contains(&name) &&
                    !reachable.contains(str::from_utf8(name.as_slice()).unwrap()) {

src/libstd/dynamic_lib.rs

@@ -232,7 +232,7 @@ mod dl {
             let ret = if ptr::null() == last_error {
                 Ok(result)
             } else {
-                let s = ffi::c_str_to_bytes(&last_error);
+                let s = ffi::c_str_to_bytes(last_error);
                 Err(str::from_utf8(s).unwrap().to_string())
             };
 

src/libstd/ffi/c_str.rs

@@ -132,13 +132,14 @@ impl fmt::Debug for CString {
 /// will then return a corresponding slice for the contents of the C string not
 /// including the nul terminator.
 ///
-/// This function will tie the lifetime of the returned slice to the lifetime of
-/// the pointer provided. This is done to help prevent the slice from escaping
-/// the lifetime of the pointer itself. If a longer lifetime is needed, then
-/// `mem::copy_lifetime` should be used.
+/// The lifetime of the returned slice is inferred from its usage in the
+/// call context. See the documentation on `std::slice::from_raw_parts`
+/// for possible pitfalls and suggested ways to mitigate them.
 ///
-/// This function is unsafe because there is no guarantee of the validity of the
-/// pointer `raw` or a guarantee that a nul terminator will be found.
+/// This function is unsafe because there is no guarantee of the validity of
+/// the pointer `raw` or a guarantee that a nul terminator will be found.
+/// There is also no guarantee whether the lifetime inferred is a suitable
+/// lifetime for the returned slice.
 ///
 /// # Example
 ///
@@ -155,23 +156,23 @@ impl fmt::Debug for CString {
 ///
 /// unsafe {
 ///     let to_print = my_string();
-///     let slice = ffi::c_str_to_bytes(&to_print);
+///     let slice = ffi::c_str_to_bytes(to_print);
 ///     println!("string returned: {}", str::from_utf8(slice).unwrap());
 /// }
 /// # }
 /// ```
-pub unsafe fn c_str_to_bytes<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
-    let len = libc::strlen(*raw);
-    slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize)
+pub unsafe fn c_str_to_bytes<'a>(raw: *const libc::c_char) -> &'a [u8] {
+    let len = libc::strlen(raw);
+    slice::from_raw_parts(raw as *const u8, len as usize)
 }
 
 /// Interpret a C string as a byte slice with the nul terminator.
 ///
-/// This function is identical to `from_raw_buf` except that the returned slice
+/// This function is identical to `c_str_to_bytes` except that the returned slice
 /// will include the nul terminator of the string.
-pub unsafe fn c_str_to_bytes_with_nul<'a>(raw: &'a *const libc::c_char) -> &'a [u8] {
-    let len = libc::strlen(*raw) + 1;
-    slice::from_raw_parts(*(raw as *const _ as *const *const u8), len as usize)
+pub unsafe fn c_str_to_bytes_with_nul<'a>(raw: *const libc::c_char) -> &'a [u8] {
+    let len = libc::strlen(raw) + 1;
+    slice::from_raw_parts(raw as *const u8, len as usize)
 }
 
 #[cfg(test)]
@@ -186,8 +187,8 @@ mod tests {
         let data = b"123\0";
         let ptr = data.as_ptr() as *const libc::c_char;
         unsafe {
-            assert_eq!(c_str_to_bytes(&ptr), b"123");
-            assert_eq!(c_str_to_bytes_with_nul(&ptr), b"123\0");
+            assert_eq!(c_str_to_bytes(ptr), b"123");
+            assert_eq!(c_str_to_bytes_with_nul(ptr), b"123\0");
         }
     }
 

src/libstd/os.rs

@@ -563,7 +563,7 @@ unsafe fn load_argc_and_argv(argc: int,
     use iter::range;
 
     (0..argc as uint).map(|i| {
-        ffi::c_str_to_bytes(&*argv.offset(i as int)).to_vec()
+        ffi::c_str_to_bytes(*argv.offset(i as int)).to_vec()
     }).collect()
 }
 
@@ -628,7 +628,7 @@ fn real_args_as_bytes() -> Vec<Vec<u8>> {
             let tmp = objc_msgSend(args, objectAtSel, i);
             let utf_c_str: *const libc::c_char =
                 mem::transmute(objc_msgSend(tmp, utf8Sel));
-            res.push(c_str_to_bytes(&utf_c_str).to_vec());
+            res.push(c_str_to_bytes(utf_c_str).to_vec());
         }
     }
 

src/libstd/rt/args.rs

@@ -99,7 +99,7 @@ mod imp {
     unsafe fn load_argc_and_argv(argc: int, argv: *const *const u8) -> Vec<Vec<u8>> {
         let argv = argv as *const *const libc::c_char;
         (0..argc as uint).map(|i| {
-            ffi::c_str_to_bytes(&*argv.offset(i as int)).to_vec()
+            ffi::c_str_to_bytes(*argv.offset(i as int)).to_vec()
         }).collect()
     }
 

src/libstd/sys/common/net.rs

@@ -325,7 +325,7 @@ pub fn get_address_name(addr: IpAddr) -> Result<String, IoError> {
     }
 
     unsafe {
-        Ok(str::from_utf8(ffi::c_str_to_bytes(&hostbuf.as_ptr()))
+        Ok(str::from_utf8(ffi::c_str_to_bytes(hostbuf.as_ptr()))
                .unwrap().to_string())
     }
 }

src/libstd/sys/unix/backtrace.rs

@@ -233,7 +233,7 @@ fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> {
         output(w, idx,addr, None)
     } else {
         output(w, idx, addr, Some(unsafe {
-            ffi::c_str_to_bytes(&info.dli_sname)
+            ffi::c_str_to_bytes(info.dli_sname)
         }))
     }
 }
@@ -364,7 +364,7 @@ fn print(w: &mut Writer, idx: int, addr: *mut libc::c_void) -> IoResult<()> {
     if ret == 0 || data.is_null() {
         output(w, idx, addr, None)
     } else {
-        output(w, idx, addr, Some(unsafe { ffi::c_str_to_bytes(&data) }))
+        output(w, idx, addr, Some(unsafe { ffi::c_str_to_bytes(data) }))
     }
 }
 

src/libstd/sys/unix/fs.rs

@@ -212,7 +212,7 @@ pub fn readdir(p: &Path) -> IoResult<Vec<Path>> {
         while unsafe { readdir_r(dir_ptr, ptr, &mut entry_ptr) == 0 } {
             if entry_ptr.is_null() { break }
             paths.push(unsafe {
-                Path::new(ffi::c_str_to_bytes(&rust_list_dir_val(entry_ptr)))
+                Path::new(ffi::c_str_to_bytes(rust_list_dir_val(entry_ptr)))
             });
         }
         assert_eq!(unsafe { closedir(dir_ptr) }, 0);

src/libstd/sys/unix/mod.rs

@@ -85,7 +85,7 @@ pub fn last_gai_error(s: libc::c_int) -> IoError {
 
     let mut err = decode_error(s);
     err.detail = Some(unsafe {
-        str::from_utf8(ffi::c_str_to_bytes(&gai_strerror(s))).unwrap().to_string()
+        str::from_utf8(ffi::c_str_to_bytes(gai_strerror(s))).unwrap().to_string()
     });
     err
 }

src/libstd/sys/unix/os.rs

@@ -90,7 +90,7 @@ pub fn error_string(errno: i32) -> String {
         }
 
         let p = p as *const _;
-        str::from_utf8(ffi::c_str_to_bytes(&p)).unwrap().to_string()
+        str::from_utf8(ffi::c_str_to_bytes(p)).unwrap().to_string()
     }
 }
 
@@ -100,7 +100,7 @@ pub fn getcwd() -> IoResult<Path> {
         if libc::getcwd(buf.as_mut_ptr(), buf.len() as libc::size_t).is_null() {
             Err(IoError::last_error())
         } else {
-            Ok(Path::new(ffi::c_str_to_bytes(&buf.as_ptr())))
+            Ok(Path::new(ffi::c_str_to_bytes(buf.as_ptr())))
         }
     }
 }
@@ -213,7 +213,7 @@ pub fn load_self() -> Option<Vec<u8>> {
         if v.is_null() {
             None
         } else {
-            Some(ffi::c_str_to_bytes(&v).to_vec())
+            Some(ffi::c_str_to_bytes(v).to_vec())
         }
     }
 }
@@ -264,7 +264,7 @@ pub fn args() -> Args {
         let (argc, argv) = (*_NSGetArgc() as isize,
                             *_NSGetArgv() as *const *const c_char);
         range(0, argc as isize).map(|i| {
-            let bytes = ffi::c_str_to_bytes(&*argv.offset(i)).to_vec();
+            let bytes = ffi::c_str_to_bytes(*argv.offset(i)).to_vec();
             OsStringExt::from_vec(bytes)
         }).collect::<Vec<_>>()
     };
@@ -322,7 +322,7 @@ pub fn args() -> Args {
             let tmp = objc_msgSend(args, objectAtSel, i);
             let utf_c_str: *const libc::c_char =
                 mem::transmute(objc_msgSend(tmp, utf8Sel));
-            let bytes = ffi::c_str_to_bytes(&utf_c_str).to_vec();
+            let bytes = ffi::c_str_to_bytes(utf_c_str).to_vec();
             res.push(OsString::from_vec(bytes))
         }
     }
@@ -377,7 +377,7 @@ pub fn env() -> Env {
         }
         let mut result = Vec::new();
         while *environ != ptr::null() {
-            result.push(parse(ffi::c_str_to_bytes(&*environ)));
+            result.push(parse(ffi::c_str_to_bytes(*environ)));
             environ = environ.offset(1);
         }
         Env { iter: result.into_iter(), _dont_send_or_sync_me: 0 as *mut _ }
@@ -399,7 +399,7 @@ pub fn getenv(k: &OsStr) -> Option<OsString> {
         if s.is_null() {
             None
         } else {
-            Some(OsStringExt::from_vec(ffi::c_str_to_bytes(&s).to_vec()))
+            Some(OsStringExt::from_vec(ffi::c_str_to_bytes(s).to_vec()))
         }
     }
 }
@@ -475,7 +475,7 @@ pub fn home_dir() -> Option<Path> {
                 _ => return None
             }
             let ptr = passwd.pw_dir as *const _;
-            let bytes = ffi::c_str_to_bytes(&ptr).to_vec();
+            let bytes = ffi::c_str_to_bytes(ptr).to_vec();
             return Some(OsStringExt::from_vec(bytes))
         }
     }

src/libstd/sys/windows/backtrace.rs

@@ -362,7 +362,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> {
         if ret == libc::TRUE {
             try!(write!(w, " - "));
             let ptr = info.Name.as_ptr() as *const libc::c_char;
-            let bytes = unsafe { ffi::c_str_to_bytes(&ptr) };
+            let bytes = unsafe { ffi::c_str_to_bytes(ptr) };
             match str::from_utf8(bytes) {
                 Ok(s) => try!(demangle(w, s)),
                 Err(..) => try!(w.write_all(&bytes[..bytes.len()-1])),

src/test/run-pass/running-with-no-runtime.rs

@@ -38,7 +38,7 @@ fn start(argc: int, argv: *const *const u8) -> int {
     let args = unsafe {
         (0..argc as uint).map(|i| {
             let ptr = *argv.offset(i as int) as *const _;
-            ffi::c_str_to_bytes(&ptr).to_vec()
+            ffi::c_str_to_bytes(ptr).to_vec()
         }).collect::<Vec<_>>()
     };
     let me = args[0].as_slice();

src/test/run-pass/variadic-ffi.rs

@@ -22,7 +22,7 @@ extern {
 unsafe fn check<T, F>(expected: &str, f: F) where F: FnOnce(*mut c_char) -> T {
     let mut x = [0 as c_char; 50];
     f(&mut x[0] as *mut c_char);
-    assert_eq!(expected.as_bytes(), ffi::c_str_to_bytes(&x.as_ptr()));
+    assert_eq!(expected.as_bytes(), ffi::c_str_to_bytes(x.as_ptr()));
 }
 
 pub fn main() {