Finish cleanup of core::str

Closes #1849

Author: marijnh

src/comp/back/link.rs

@@ -109,13 +109,10 @@ mod write {
     // Decides what to call an intermediate file, given the name of the output
     // and the extension to use.
     fn mk_intermediate_name(output_path: str, extension: str) -> str unsafe {
-        let stem = alt str::index(output_path, '.') {
-                       option::some(dot_pos) {
-                           str::slice(output_path, 0u, dot_pos)
-                       }
-                       option::none { output_path }
-                   };
-
+        let stem = alt str::find_char(output_path, '.') {
+          some(dot_pos) { str::slice(output_path, 0u, dot_pos) }
+          none { output_path }
+        };
         ret stem + "." + extension;
     }
 
@@ -566,7 +563,7 @@ fn link_binary(sess: session,
     // Converts a library file name into a cc -l argument
     fn unlib(config: @session::config, filename: str) -> str unsafe {
         let rmlib = fn@(filename: str) -> str {
-            let found = str::find(filename, "lib");
+            let found = str::find_str(filename, "lib");
             if config.os == session::os_macos ||
                 (config.os == session::os_linux ||
                  config.os == session::os_freebsd) &&

src/comp/syntax/codemap.rs

@@ -157,22 +157,20 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
 
 fn get_line(fm: filemap, line: int) -> str unsafe {
     let begin: uint = fm.lines[line].byte - fm.start_pos.byte;
-    let end = alt str::index_from(*fm.src, '\n', begin, str::len(*fm.src)) {
+    let end = alt str::find_char_from(*fm.src, '\n', begin) {
       some(e) { e }
       none { str::len(*fm.src) }
     };
     str::slice(*fm.src, begin, end)
 }
 
 fn lookup_byte_offset(cm: codemap::codemap, chpos: uint)
-    -> {fm: filemap, pos: uint}
-{
-    fn lookup(pos: file_pos) -> uint { ret pos.ch; }
-    let {fm,line} = lookup_line(cm,chpos,lookup);
+    -> {fm: filemap, pos: uint} {
+    let {fm, line} = lookup_line(cm, chpos, {|pos| pos.ch});
     let line_offset = fm.lines[line].byte - fm.start_pos.byte;
     let col = chpos - fm.lines[line].ch;
-    let col_offset = str::substr_len(*fm.src, line_offset, col);
-    ret {fm: fm, pos: line_offset + col_offset};
+    let col_offset = str::count_bytes(*fm.src, line_offset, col);
+    {fm: fm, pos: line_offset + col_offset}
 }
 
 fn span_to_snippet(sp: span, cm: codemap::codemap) -> str {

src/comp/syntax/ext/qquote.rs

@@ -214,7 +214,7 @@ fn finish<T: qq_helper>
         if (j < g_len && i == cx.gather[j].lo) {
             assert ch == '$';
             let repl = #fmt("$%u ", j);
-            state = skip(str::len_chars(repl));
+            state = skip(str::char_len(repl));
             str2 += repl;
         }
         alt state {

src/compiletest/errors.rs

@@ -25,7 +25,7 @@ fn load_errors(testfile: str) -> [expected_error] {
 fn parse_expected(line_num: uint, line: str) -> [expected_error] unsafe {
     let error_tag = "//!";
     let idx;
-    alt str::find(line, error_tag) {
+    alt str::find_str(line, error_tag) {
          option::none { ret []; }
          option::some(nn) { idx = (nn as uint) + str::len(error_tag); }
     }

src/compiletest/header.rs

@@ -106,7 +106,7 @@ fn parse_name_directive(line: str, directive: str) -> bool {
 fn parse_name_value_directive(line: str,
                               directive: str) -> option<str> unsafe {
     let keycolon = directive + ":";
-    alt str::find(line, keycolon) {
+    alt str::find_str(line, keycolon) {
         option::some(colon) {
             let value = str::slice(line, colon + str::len(keycolon),
                                    str::len(line));

src/compiletest/runtest.rs

@@ -198,7 +198,7 @@ fn check_error_patterns(props: test_props,
 
     let next_err_idx = 0u;
     let next_err_pat = props.error_patterns[next_err_idx];
-    for line: str in str::split_byte(procres.stderr, '\n' as u8) {
+    for line: str in str::split_char(procres.stderr, '\n') {
         if str::contains(line, next_err_pat) {
             #debug("found error pattern %s", next_err_pat);
             next_err_idx += 1u;
@@ -245,7 +245,7 @@ fn check_expected_errors(expected_errors: [errors::expected_error],
     //    filename:line1:col1: line2:col2: *warning:* msg
     // where line1:col1: is the starting point, line2:col2:
     // is the ending point, and * represents ANSI color codes.
-    for line: str in str::split_byte(procres.stderr, '\n' as u8) {
+    for line: str in str::split_char(procres.stderr, '\n') {
         let was_expected = false;
         vec::iteri(expected_errors) {|i, ee|
             if !found_flags[i] {
@@ -350,7 +350,7 @@ fn split_maybe_args(argstr: option<str>) -> [str] {
     }
 
     alt argstr {
-      option::some(s) { rm_whitespace(str::split_byte(s, ' ' as u8)) }
+      option::some(s) { rm_whitespace(str::split_char(s, ' ')) }
       option::none { [] }
     }
 }
@@ -410,12 +410,10 @@ fn make_out_name(config: config, testfile: str, extension: str) -> str {
 
 fn output_base_name(config: config, testfile: str) -> str {
     let base = config.build_base;
-    let filename =
-        {
-            let parts = str::split_byte(fs::basename(testfile), '.' as u8);
-            parts = vec::slice(parts, 0u, vec::len(parts) - 1u);
-            str::connect(parts, ".")
-        };
+    let filename = {
+        let parts = str::split_char(fs::basename(testfile), '.');
+        str::connect(vec::slice(parts, 0u, vec::len(parts) - 1u), ".")
+    };
     #fmt["%s%s.%s", base, filename, config.stage_id]
 }
 

src/libcore/extfmt.rs

@@ -320,16 +320,14 @@ mod rt {
     fn conv_str(cv: conv, s: str) -> str unsafe {
         // For strings, precision is the maximum characters
         // displayed
-
-        let unpadded =
-            alt cv.precision {
-              count_implied { s }
-              count_is(max) {
-                if max as uint < str::len_chars(s) {
-                    str::substr(s, 0u, max as uint)
-                } else { s }
-              }
-            };
+        let unpadded = alt cv.precision {
+          count_implied { s }
+          count_is(max) {
+            if max as uint < str::char_len(s) {
+                str::substr(s, 0u, max as uint)
+            } else { s }
+          }
+        };
         ret pad(cv, unpadded, pad_nozero);
     }
     fn conv_float(cv: conv, f: float) -> str {
@@ -368,7 +366,7 @@ mod rt {
                 ""
             } else {
                 let s = uint::to_str(num, radix);
-                let len = str::len_chars(s);
+                let len = str::char_len(s);
                 if len < prec {
                     let diff = prec - len;
                     let pad = str_init_elt(diff, '0');
@@ -400,7 +398,7 @@ mod rt {
             uwidth = width as uint;
           }
         }
-        let strlen = str::len_chars(s);
+        let strlen = str::char_len(s);
         if uwidth <= strlen { ret s; }
         let padchar = ' ';
         let diff = uwidth - strlen;