(core::char) rename slice -> slice_chars

src/cargo/cargo.rs

@@ -177,7 +177,7 @@ fn rest(s: str, start: uint) -> str {
     if (start >= str::len_chars(s)) {
         ""
     } else {
-        str::slice(s, start, str::len_chars(s))
+        str::slice_chars(s, start, str::len_chars(s))
     }
 }
 
@@ -688,8 +688,8 @@ fn cmd_install(c: cargo) unsafe {
         let uuid = rest(target, 5u);
         alt str::index_chars(uuid, '/') {
             option::some(idx) {
-               let source = str::slice(uuid, 0u, idx);
+               let source = str::slice_chars(uuid, 0u, idx);
-               uuid = str::slice(uuid, idx + 1u, str::len_chars(uuid));
+               uuid = str::slice_chars(uuid, idx + 1u, str::len_chars(uuid));
                install_uuid_specific(c, wd, source, uuid);
             }
             option::none {
@@ -700,8 +700,8 @@ fn cmd_install(c: cargo) unsafe {
         let name = target;
         alt str::index_chars(name, '/') {
             option::some(idx) {
-               let source = str::slice(name, 0u, idx);
+               let source = str::slice_chars(name, 0u, idx);
-               name = str::slice(name, idx + 1u, str::len_chars(name));
+               name = str::slice_chars(name, idx + 1u, str::len_chars(name));
                install_named_specific(c, wd, source, name);
             }
             option::none {

src/comp/back/link.rs

@@ -111,7 +111,7 @@ mod write {
     fn mk_intermediate_name(output_path: str, extension: str) -> str unsafe {
         let stem = alt str::index_chars(output_path, '.') {
                        option::some(dot_pos) {
-                           str::slice(output_path, 0u, dot_pos)
+                           str::slice_chars(output_path, 0u, dot_pos)
                        }
                        option::none { output_path }
                    };

src/comp/syntax/codemap.rs

@@ -180,13 +180,13 @@ fn span_to_snippet(sp: span, cm: codemap::codemap) -> str {
     let begin = lookup_byte_offset(cm,sp.lo);
     let end   = lookup_byte_offset(cm,sp.hi);
     assert begin.fm == end.fm;
-    ret str::slice(*begin.fm.src, begin.pos, end.pos);
+    ret str::slice_chars(*begin.fm.src, begin.pos, end.pos);
 }
 
 fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> str
 {
     let fm = cm.files[fidx];
-    ret str::slice(*fm.src, lo, hi)
+    ret str::slice_chars(*fm.src, lo, hi)
 }
 
 fn get_filemap(cm: codemap, filename: str) -> filemap {

src/fuzzer/fuzzer.rs

@@ -287,7 +287,7 @@ fn check_variants_T<T: copy>(
 
 fn last_part(filename: str) -> str {
   let ix = option::get(str::rindex_chars(filename, '/'));
-  str::slice(filename, ix + 1u, str::len_chars(filename) - 3u)
+  str::slice_chars(filename, ix + 1u, str::len_chars(filename) - 3u)
 }
 
 enum happiness { passed, cleanly_rejected(str), known_bug(str), failed(str), }

src/libcore/str.rs

@@ -36,7 +36,7 @@ export
    bytes,
    chars,
    substr,
-   slice,
+   slice_chars,
    split,
    split_str,
    split_char,
@@ -391,11 +391,11 @@ Failure:
 If `begin` + `len` is is greater than the char length of the string
 */
 fn substr(s: str, begin: uint, len: uint) -> str {
-    ret slice(s, begin, begin + len);
+    ret slice_chars(s, begin, begin + len);
 }
 
 /*
-Function: slice
+Function: slice_chars
 
 Unicode-safe slice. Returns a slice of the given string containing
 the characters in the range [`begin`..`end`). `begin` and `end` are
@@ -408,7 +408,7 @@ Failure:
 
 FIXME: make faster by avoiding char conversion
 */
-fn slice(s: str, begin: uint, end: uint) -> str {
+fn slice_chars(s: str, begin: uint, end: uint) -> str {
     from_chars(vec::slice(chars(s), begin, end))
 }
 
@@ -617,7 +617,7 @@ fn windowed(nn: uint, ss: str) -> [str] {
 
     let ii = 0u;
     while ii+nn <= len {
-        let w = slice( ss, ii, ii+nn );
+        let w = slice_chars( ss, ii, ii+nn );
         vec::push(ww,w);
         ii += 1u;
     }
@@ -1969,17 +1969,17 @@ mod tests {
     }
 
     #[test]
-    fn test_slice() {
+    fn test_slice_chars() {
-        assert (eq("ab", slice("abc", 0u, 2u)));
+        assert (eq("ab", slice_chars("abc", 0u, 2u)));
-        assert (eq("bc", slice("abc", 1u, 3u)));
+        assert (eq("bc", slice_chars("abc", 1u, 3u)));
-        assert (eq("", slice("abc", 1u, 1u)));
+        assert (eq("", slice_chars("abc", 1u, 1u)));
-        assert (eq("\u65e5", slice("\u65e5\u672c", 0u, 1u)));
+        assert (eq("\u65e5", slice_chars("\u65e5\u672c", 0u, 1u)));
 
         let data = "ประเทศไทย中华";
-        assert (eq("ป", slice(data, 0u, 1u)));
+        assert (eq("ป", slice_chars(data, 0u, 1u)));
-        assert (eq("ร", slice(data, 1u, 2u)));
+        assert (eq("ร", slice_chars(data, 1u, 2u)));
-        assert (eq("华", slice(data, 10u, 11u)));
+        assert (eq("华", slice_chars(data, 10u, 11u)));
-        assert (eq("", slice(data, 1u, 1u)));
+        assert (eq("", slice_chars(data, 1u, 1u)));
 
         fn a_million_letter_X() -> str {
             let i = 0;
@@ -1994,7 +1994,7 @@ mod tests {
             ret rs;
         }
         assert (eq(half_a_million_letter_X(),
-                        slice(a_million_letter_X(), 0u, 500000u)));
+                        slice_chars(a_million_letter_X(), 0u, 500000u)));
     }
 
     #[test]

src/libstd/fs.rs

@@ -44,8 +44,8 @@ fn splitDirnameBasename (pp: path) -> {dirname: str, basename: str} {
         }
     }
 
-    ret {dirname: str::slice(pp, 0u, ii),
+    ret {dirname: str::slice_chars(pp, 0u, ii),
-         basename: str::slice(pp, ii + 1u, str::len_chars(pp))};
+         basename: str::slice_chars(pp, ii + 1u, str::len_chars(pp))};
 }
 
 /*

src/libstd/json.rs

@@ -71,7 +71,7 @@ fn to_str(j: json) -> str {
 
 fn rest(s: str) -> str {
     assert(str::len_chars(s) >= 1u);
-    str::slice(s, 1u, str::len_chars(s))
+    str::slice_chars(s, 1u, str::len_chars(s))
 }
 
 fn from_str_str(s: str) -> (option<json>, str) {
@@ -99,7 +99,7 @@ fn from_str_str(s: str) -> (option<json>, str) {
             cont;
         } else if (c == '"') {
             ret (some(string(res)),
-                 str::slice(s, pos, str::len_chars(s)));
+                 str::slice_chars(s, pos, str::len_chars(s)));
         }
         res = res + str::from_char(c);
     }
@@ -200,12 +200,13 @@ fn from_str_float(s: str) -> (option<json>, str) {
             }
             '.' { break; }
             _ { ret (some(num(neg * res)),
-                     str::slice(s, opos, str::len_chars(s))); }
+                     str::slice_chars(s, opos, str::len_chars(s))); }
         }
     }
 
     if pos == len {
-        ret (some(num(neg * res)), str::slice(s, pos, str::len_chars(s)));
+        ret (some(num(neg * res)),
+             str::slice_chars(s, pos, str::len_chars(s)));
     }
 
     let dec = 1f;
@@ -220,17 +221,17 @@ fn from_str_float(s: str) -> (option<json>, str) {
                 res += (((c as int) - ('0' as int)) as float) * dec;
             }
             _ { ret (some(num(neg * res)),
-                     str::slice(s, opos, str::len_chars(s))); }
+                     str::slice_chars(s, opos, str::len_chars(s))); }
         }
     }
-    ret (some(num(neg * res)), str::slice(s, pos, str::len_chars(s)));
+    ret (some(num(neg * res)), str::slice_chars(s, pos, str::len_chars(s)));
 }
 
 fn from_str_bool(s: str) -> (option<json>, str) {
     if (str::starts_with(s, "true")) {
-        (some(boolean(true)), str::slice(s, 4u, str::len_chars(s)))
+        (some(boolean(true)), str::slice_chars(s, 4u, str::len_chars(s)))
     } else if (str::starts_with(s, "false")) {
-        (some(boolean(false)), str::slice(s, 5u, str::len_chars(s)))
+        (some(boolean(false)), str::slice_chars(s, 5u, str::len_chars(s)))
     } else {
         (none, s)
     }
@@ -238,7 +239,7 @@ fn from_str_bool(s: str) -> (option<json>, str) {
 
 fn from_str_null(s: str) -> (option<json>, str) {
     if (str::starts_with(s, "null")) {
-        (some(null), str::slice(s, 4u, str::len_chars(s)))
+        (some(null), str::slice_chars(s, 4u, str::len_chars(s)))
     } else {
         (none, s)
     }

src/rustdoc/unindent_pass.rs

@@ -68,7 +68,7 @@ fn unindent(s: str) -> str {
                 line
             } else {
                 assert str::len_bytes(line) >= min_indent;
-                str::slice(line, min_indent, str::len_chars(line))
+                str::slice_chars(line, min_indent, str::len_chars(line))
             }
         };
         str::connect(unindented, "\n")