---

yaml
---
r: 78802
b: refs/heads/try
c: a903f74
h: refs/heads/master
v: v3

Author: vadimcn

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 25ed29a0edb3d48fef843a0b818ee68faf2252da
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 60fba4d7d677ec098e6a43014132fe99f7547363
-refs/heads/try: bdd188d003b56b55f534ad692ea1b17ca569b6fe
+refs/heads/try: a903f741b076bc8031d7789b83efe789d8ca65ae
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/compiletest/runtest.rs

@@ -282,7 +282,9 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
     }
 
     // write debugger script
-    let script_str = cmds.append("\nquit\n");
+    let script_str = [~"set charset UTF-8",
+                      cmds,
+                      ~"quit\n"].connect("\n");
     debug!("script_str = %s", script_str);
     dump_output_file(config, testfile, script_str, "debugger.script");
 

branches/try/src/libstd/str.rs

@@ -56,23 +56,12 @@ Section: Creating a string
 pub fn from_bytes(vv: &[u8]) -> ~str {
     use str::not_utf8::cond;
 
-    match from_bytes_opt(vv) {
-        None => {
-            let first_bad_byte = *vv.iter().find(|&b| !is_utf8([*b])).unwrap();
-            cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
-                            first_bad_byte as uint))
-        }
-        Some(s) => s
-    }
-}
-
-/// Convert a vector of bytes to a new UTF-8 string, if possible.
-/// Returns None if the vector contains invalid UTF-8.
-pub fn from_bytes_opt(vv: &[u8]) -> Option<~str> {
-    if is_utf8(vv) {
-        Some(unsafe { raw::from_bytes(vv) })
+    if !is_utf8(vv) {
+        let first_bad_byte = *vv.iter().find(|&b| !is_utf8([*b])).unwrap();
+        cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
+                        first_bad_byte as uint))
     } else {
-        None
+        return unsafe { raw::from_bytes(vv) }
     }
 }
 
@@ -89,17 +78,7 @@ pub fn from_bytes_owned(vv: ~[u8]) -> ~str {
         cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
                         first_bad_byte as uint))
     } else {
-        unsafe { raw::from_bytes_owned(vv) }
-    }
-}
-
-/// Consumes a vector of bytes to create a new utf-8 string.
-/// Returns None if the vector contains invalid UTF-8.
-pub fn from_bytes_owned_opt(vv: ~[u8]) -> Option<~str> {
-    if is_utf8(vv) {
-        Some(unsafe { raw::from_bytes_owned(vv) })
-    } else {
-        None
+        return unsafe { raw::from_bytes_owned(vv) }
     }
 }
 
@@ -112,16 +91,8 @@ pub fn from_bytes_owned_opt(vv: ~[u8]) -> Option<~str> {
 ///
 /// Fails if invalid UTF-8
 pub fn from_bytes_slice<'a>(v: &'a [u8]) -> &'a str {
-    from_bytes_slice_opt(v).expect("from_bytes_slice: not utf-8")
-}
-
-/// Converts a vector to a string slice without performing any allocations.
-///
-/// Returns None if the slice is not utf-8.
-pub fn from_bytes_slice_opt<'a>(v: &'a [u8]) -> Option<&'a str> {
-    if is_utf8(v) {
-        Some(unsafe { cast::transmute(v) })
-    } else { None }
+    assert!(is_utf8(v));
+    unsafe { cast::transmute(v) }
 }
 
 impl ToStr for ~str {
@@ -2387,7 +2358,7 @@ impl Zero for @str {
 #[cfg(test)]
 mod tests {
     use container::Container;
-    use option::{None, Some};
+    use option::Some;
     use libc::c_char;
     use libc;
     use ptr;
@@ -3568,76 +3539,6 @@ mod tests {
         let mut s = ~"\u00FC"; // ü
         s.truncate(1);
     }
-
-    #[test]
-    fn test_str_from_bytes_slice() {
-        let xs = bytes!("hello");
-        assert_eq!(from_bytes_slice(xs), "hello");
-
-        let xs = bytes!("ศไทย中华Việt Nam");
-        assert_eq!(from_bytes_slice(xs), "ศไทย中华Việt Nam");
-    }
-
-    #[test]
-    #[should_fail]
-    fn test_str_from_bytes_slice_invalid() {
-        let xs = bytes!("hello", 0xff);
-        let _ = from_bytes_slice(xs);
-    }
-
-    #[test]
-    fn test_str_from_bytes_slice_opt() {
-        let xs = bytes!("hello");
-        assert_eq!(from_bytes_slice_opt(xs), Some("hello"));
-
-        let xs = bytes!("ศไทย中华Việt Nam");
-        assert_eq!(from_bytes_slice_opt(xs), Some("ศไทย中华Việt Nam"));
-
-        let xs = bytes!("hello", 0xff);
-        assert_eq!(from_bytes_slice_opt(xs), None);
-    }
-
-    #[test]
-    fn test_str_from_bytes() {
-        let xs = bytes!("hello");
-        assert_eq!(from_bytes(xs), ~"hello");
-
-        let xs = bytes!("ศไทย中华Việt Nam");
-        assert_eq!(from_bytes(xs), ~"ศไทย中华Việt Nam");
-    }
-
-    #[test]
-    fn test_str_from_bytes_opt() {
-        let xs = bytes!("hello").to_owned();
-        assert_eq!(from_bytes_opt(xs), Some(~"hello"));
-
-        let xs = bytes!("ศไทย中华Việt Nam");
-        assert_eq!(from_bytes_opt(xs), Some(~"ศไทย中华Việt Nam"));
-
-        let xs = bytes!("hello", 0xff);
-        assert_eq!(from_bytes_opt(xs), None);
-    }
-
-    #[test]
-    fn test_str_from_bytes_owned() {
-        let xs = bytes!("hello").to_owned();
-        assert_eq!(from_bytes_owned(xs), ~"hello");
-
-        let xs = bytes!("ศไทย中华Việt Nam").to_owned();
-        assert_eq!(from_bytes_owned(xs), ~"ศไทย中华Việt Nam");
-    }
-
-    #[test]
-    fn test_str_from_bytes_owned_opt() {
-        let xs = bytes!("hello").to_owned();
-        assert_eq!(from_bytes_owned_opt(xs), Some(~"hello"));
-
-        let xs = bytes!("ศไทย中华Việt Nam").to_owned();
-        assert_eq!(from_bytes_owned_opt(xs), Some(~"ศไทย中华Việt Nam"));
-
-        let xs = bytes!("hello", 0xff).to_owned();
-        assert_eq!(from_bytes_owned_opt(xs), None);
-    }
 }
 
 #[cfg(test)]