Split CString::new into CString::new and CString::new_owned

src/libcollections/str.rs

@@ -1348,13 +1348,13 @@ mod tests {
     #[test]
     fn test_slice_shift_char() {
         let data = "ประเทศไทย中";
-        assert_eq!(data.slice_shift_char(), (Some('ป'), "ระเทศไทย中"));
+        assert_eq!(data.slice_shift_char(), Some(('ป', "ระเทศไทย中")));
     }
 
     #[test]
     fn test_slice_shift_char_2() {
         let empty = "";
-        assert_eq!(empty.slice_shift_char(), (None, ""));
+        assert_eq!(empty.slice_shift_char(), None);
     }
 
     #[test]

src/libcore/str.rs

@@ -1784,21 +1784,21 @@ pub trait StrSlice<'a> {
     /// it. This does not allocate a new string; instead, it returns a
     /// slice that point one character beyond the character that was
     /// shifted. If the string does not contain any characters,
-    /// a tuple of None and an empty string is returned instead.
+    /// None is returned instead.
     ///
     /// # Example
     ///
     /// ```rust
     /// let s = "Löwe 老虎 Léopard";
-    /// let (c, s1) = s.slice_shift_char();
-    /// assert_eq!(c, Some('L'));
+    /// let (c, s1) = s.slice_shift_char().unwrap();
+    /// assert_eq!(c, 'L');
     /// assert_eq!(s1, "öwe 老虎 Léopard");
     ///
-    /// let (c, s2) = s1.slice_shift_char();
-    /// assert_eq!(c, Some('ö'));
+    /// let (c, s2) = s1.slice_shift_char().unwrap();
+    /// assert_eq!(c, 'ö');
     /// assert_eq!(s2, "we 老虎 Léopard");
     /// ```
-    fn slice_shift_char(&self) -> (Option<char>, &'a str);
+    fn slice_shift_char(&self) -> Option<(char, &'a str)>;
 
     /// Returns the byte offset of an inner slice relative to an enclosing outer slice.
     ///
@@ -2148,13 +2148,13 @@ impl<'a> StrSlice<'a> for &'a str {
     }
 
     #[inline]
-    fn slice_shift_char(&self) -> (Option<char>, &'a str) {
+    fn slice_shift_char(&self) -> Option<(char, &'a str)> {
         if self.is_empty() {
-            return (None, *self);
+            return None;
         } else {
             let CharRange {ch, next} = self.char_range_at(0u);
             let next_s = unsafe { raw::slice_bytes(*self, next, self.len()) };
-            return (Some(ch), next_s);
+            return Some((ch, next_s));
         }
     }
 

src/libcoretest/ptr.rs

@@ -211,7 +211,7 @@ fn test_ptr_array_each_with_len() {
         let mut ctr = 0;
         let mut iteration_count = 0;
         array_each_with_len(arr.as_ptr(), arr.len(), |e| {
-                let actual = CString::new(e, false);
+                let actual = CString::new(e);
                 assert_eq!(actual.as_str(), expected_arr[ctr].as_str());
                 ctr += 1;
                 iteration_count += 1;
@@ -241,7 +241,7 @@ fn test_ptr_array_each() {
         let mut ctr = 0u;
         let mut iteration_count = 0u;
         array_each(arr_ptr, |e| {
-                let actual = CString::new(e, false);
+                let actual = CString::new(e);
                 assert_eq!(actual.as_str(), expected_arr[ctr].as_str());
                 ctr += 1;
                 iteration_count += 1;
@@ -255,7 +255,7 @@ fn test_ptr_array_each() {
 fn test_ptr_array_each_with_len_null_ptr() {
     unsafe {
         array_each_with_len(0 as *const *const libc::c_char, 1, |e| {
-            CString::new(e, false).as_str().unwrap();
+            CString::new(e).as_str().unwrap();
         });
     }
 }
@@ -264,7 +264,7 @@ fn test_ptr_array_each_with_len_null_ptr() {
 fn test_ptr_array_each_null_ptr() {
     unsafe {
         array_each(0 as *const *const libc::c_char, |e| {
-            CString::new(e, false).as_str().unwrap();
+            CString::new(e).as_str().unwrap();
         });
     }
 }

src/libglob/lib.rs

@@ -404,11 +404,11 @@ impl Pattern {
                             return EntirePatternDoesntMatch;
                         }
 
-                        let (some_c, next) = file.slice_shift_char();
-                        if require_literal(some_c.unwrap()) {
+                        let (c, next) = file.slice_shift_char().unwrap();
+                        if require_literal(c) {
                             return SubPatternDoesntMatch;
                         }
-                        prev_char.set(some_c);
+                        prev_char.set(Some(c));
                         file = next;
                     }
                 }
@@ -417,8 +417,7 @@ impl Pattern {
                         return EntirePatternDoesntMatch;
                     }
 
-                    let (some_c, next) = file.slice_shift_char();
-                    let c = some_c.unwrap();
+                    let (c, next) = file.slice_shift_char().unwrap();
                     let matches = match *token {
                         AnyChar => {
                             !require_literal(c)
@@ -445,7 +444,7 @@ impl Pattern {
                     if !matches {
                         return SubPatternDoesntMatch;
                     }
-                    prev_char.set(some_c);
+                    prev_char.set(Some(c));
                     file = next;
                 }
             }

src/libnative/io/addrinfo.rs

@@ -106,7 +106,7 @@ fn get_error(s: c_int) -> IoError {
     use std::c_str::CString;
 
     let err_str = unsafe {
-        CString::new(gai_strerror(s), false).as_str().unwrap().to_string()
+        CString::new(gai_strerror(s)).as_str().unwrap().to_string()
     };
     IoError {
         code: s as uint,

src/libnative/io/file_unix.rs

@@ -351,7 +351,7 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
     use libc::{opendir, readdir_r, closedir};
 
     fn prune(root: &CString, dirs: Vec<Path>) -> Vec<CString> {
-        let root = unsafe { CString::new(root.as_ptr(), false) };
+        let root = unsafe { CString::new(root.as_ptr()) };
         let root = Path::new(root);
 
         dirs.into_iter().filter(|path| {
@@ -376,7 +376,7 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
         while unsafe { readdir_r(dir_ptr, ptr, &mut entry_ptr) == 0 } {
             if entry_ptr.is_null() { break }
             let cstr = unsafe {
-                CString::new(rust_list_dir_val(entry_ptr), false)
+                CString::new(rust_list_dir_val(entry_ptr))
             };
             paths.push(Path::new(cstr));
         }

src/libnative/io/file_windows.rs

@@ -343,7 +343,7 @@ pub fn mkdir(p: &CString, _mode: uint) -> IoResult<()> {
 
 pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
     fn prune(root: &CString, dirs: Vec<Path>) -> Vec<CString> {
-        let root = unsafe { CString::new(root.as_ptr(), false) };
+        let root = unsafe { CString::new(root.as_ptr()) };
         let root = Path::new(root);
 
         dirs.into_iter().filter(|path| {
@@ -352,7 +352,7 @@ pub fn readdir(p: &CString) -> IoResult<Vec<CString>> {
     }
 
     let star = Path::new(unsafe {
-        CString::new(p.as_ptr(), false)
+        CString::new(p.as_ptr())
     }).join("*");
     let path = try!(to_utf16(&star.to_c_str()));
 

src/librustc/back/write.rs

@@ -46,10 +46,10 @@ pub enum OutputType {
 pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! {
     unsafe {
         let cstr = llvm::LLVMRustGetLastError();
-        if cstr == ptr::null() {
+        if cstr as *const i8 == ptr::null() {
             handler.fatal(msg.as_slice());
         } else {
-            let err = CString::new(cstr, true);
+            let err = CString::new_owned(cstr);
             let err = String::from_utf8_lossy(err.as_bytes());
             handler.fatal(format!("{}: {}",
                                   msg.as_slice(),
@@ -367,7 +367,7 @@ unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_vo
 
     match llvm::diagnostic::Diagnostic::unpack(info) {
         llvm::diagnostic::Optimization(opt) => {
-            let pass_name = CString::new(opt.pass_name, false);
+            let pass_name = CString::new(opt.pass_name);
             let pass_name = pass_name.as_str().expect("got a non-UTF8 pass name from LLVM");
             let enabled = match cgcx.remark {
                 AllPasses => true,

src/librustc/middle/trans/base.rs

@@ -2965,7 +2965,7 @@ fn internalize_symbols(cx: &SharedCrateContext, reachable: &HashSet<String>) {
                     continue
                 }
 
-                let name = CString::new(llvm::LLVMGetValueName(val), false);
+                let name = CString::new(llvm::LLVMGetValueName(val));
                 declared.insert(name);
             }
         }
@@ -2981,7 +2981,7 @@ fn internalize_symbols(cx: &SharedCrateContext, reachable: &HashSet<String>) {
                     continue
                 }
 
-                let name = CString::new(llvm::LLVMGetValueName(val), false);
+                let name = CString::new(llvm::LLVMGetValueName(val));
                 if !declared.contains(&name) &&
                    !reachable.contains_equiv(&name.as_str().unwrap()) {
                     llvm::SetLinkage(val, llvm::InternalLinkage);

src/librustc_llvm/lib.rs

@@ -1625,7 +1625,7 @@ extern {
 
     /** Returns a string describing the last error caused by an LLVMRust*
     call. */
-    pub fn LLVMRustGetLastError() -> *const c_char;
+    pub fn LLVMRustGetLastError() -> *mut c_char;
 
     /// Print the pass timings since static dtors aren't picking them up.
     pub fn LLVMRustPrintPassTimings();