diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index f9c3894e274f..4de7b89ba6f2 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -48,9 +48,7 @@ fn start(argc: int, argv: **u8) -> int {
 
 pub fn main() {
     let args = os::args();
-    let config = parse_config(args.move_iter()
-                                  .map(|x| x.to_string())
-                                  .collect());
+    let config = parse_config(args);
     log_config(&config);
     run_tests(&config);
 }
@@ -131,17 +129,15 @@ pub fn parse_config(args: Vec<String> ) -> Config {
     };
 
     Config {
-        compile_lib_path: matches.opt_str("compile-lib-path")
-                                 .unwrap()
-                                 .to_string(),
-        run_lib_path: matches.opt_str("run-lib-path").unwrap().to_string(),
+        compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
+        run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
         clang_path: matches.opt_str("clang-path").map(|s| Path::new(s)),
         llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| Path::new(s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
-        stage_id: matches.opt_str("stage-id").unwrap().to_string(),
+        stage_id: matches.opt_str("stage-id").unwrap(),
         mode: FromStr::from_str(matches.opt_str("mode")
                                        .unwrap()
                                        .as_slice()).expect("invalid mode"),
@@ -155,32 +151,23 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         ratchet_noise_percent:
             matches.opt_str("ratchet-noise-percent")
                    .and_then(|s| from_str::<f64>(s.as_slice())),
-        runtool: matches.opt_str("runtool").map(|x| x.to_string()),
-        host_rustcflags: matches.opt_str("host-rustcflags")
-                                .map(|x| x.to_string()),
-        target_rustcflags: matches.opt_str("target-rustcflags")
-                                  .map(|x| x.to_string()),
+        runtool: matches.opt_str("runtool"),
+        host_rustcflags: matches.opt_str("host-rustcflags"),
+        target_rustcflags: matches.opt_str("target-rustcflags"),
         jit: matches.opt_present("jit"),
-        target: opt_str2(matches.opt_str("target").map(|x| x.to_string())),
-        host: opt_str2(matches.opt_str("host").map(|x| x.to_string())),
+        target: opt_str2(matches.opt_str("target")),
+        host: opt_str2(matches.opt_str("host")),
         android_cross_path: opt_path(matches, "android-cross-path"),
-        adb_path: opt_str2(matches.opt_str("adb-path")
-                                  .map(|x| x.to_string())),
-        adb_test_dir: opt_str2(matches.opt_str("adb-test-dir")
-                                      .map(|x| x.to_string())),
+        adb_path: opt_str2(matches.opt_str("adb-path")),
+        adb_test_dir: opt_str2(matches.opt_str("adb-test-dir")),
         adb_device_status:
             "arm-linux-androideabi" ==
-                opt_str2(matches.opt_str("target")
-                                .map(|x| x.to_string())).as_slice() &&
+                opt_str2(matches.opt_str("target")).as_slice() &&
             "(none)" !=
-                opt_str2(matches.opt_str("adb-test-dir")
-                                .map(|x| x.to_string())).as_slice() &&
-            !opt_str2(matches.opt_str("adb-test-dir")
-                             .map(|x| x.to_string())).is_empty(),
-        lldb_python_dir: matches.opt_str("lldb-python-dir")
-                                .map(|x| x.to_string()),
-        test_shard: test::opt_shard(matches.opt_str("test-shard")
-                                           .map(|x| x.to_string())),
+                opt_str2(matches.opt_str("adb-test-dir")).as_slice() &&
+            !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
+        lldb_python_dir: matches.opt_str("lldb-python-dir"),
+        test_shard: test::opt_shard(matches.opt_str("test-shard")),
         verbose: matches.opt_present("verbose")
     }
 }
diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs
index 4b0b68bca997..6ef2a52086e2 100644
--- a/src/compiletest/header.rs
+++ b/src/compiletest/header.rs
@@ -170,23 +170,23 @@ fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool {
 }
 
 fn parse_error_pattern(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "error-pattern".to_string())
+    parse_name_value_directive(line, "error-pattern")
 }
 
 fn parse_aux_build(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "aux-build".to_string())
+    parse_name_value_directive(line, "aux-build")
 }
 
 fn parse_compile_flags(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "compile-flags".to_string())
+    parse_name_value_directive(line, "compile-flags")
 }
 
 fn parse_run_flags(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "run-flags".to_string())
+    parse_name_value_directive(line, "run-flags")
 }
 
 fn parse_check_line(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "check".to_string())
+    parse_name_value_directive(line, "check")
 }
 
 fn parse_force_host(line: &str) -> bool {
@@ -206,7 +206,7 @@ fn parse_no_pretty_expanded(line: &str) -> bool {
 }
 
 fn parse_exec_env(line: &str) -> Option<(String, String)> {
-    parse_name_value_directive(line, "exec-env".to_string()).map(|nv| {
+    parse_name_value_directive(line, "exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR
         let mut strs: Vec<String> = nv.as_slice()
                                       .splitn('=', 1)
@@ -225,7 +225,7 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
 }
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
-    match parse_name_value_directive(line, "pp-exact".to_string()) {
+    match parse_name_value_directive(line, "pp-exact") {
       Some(s) => Some(Path::new(s)),
       None => {
         if parse_name_directive(line, "pp-exact") {
@@ -241,7 +241,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
     line.contains(directive)
 }
 
-pub fn parse_name_value_directive(line: &str, directive: String)
+pub fn parse_name_value_directive(line: &str, directive: &str)
                                   -> Option<String> {
     let keycolon = format!("{}:", directive);
     match line.find_str(keycolon.as_slice()) {
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index ce3c2d7de809..ee69ab7cc520 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -73,7 +73,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = compile_test(config, props, testfile);
 
     if proc_res.status.success() {
-        fatal_proc_rec("compile-fail test compiled successfully!".to_string(),
+        fatal_proc_rec("compile-fail test compiled successfully!",
                       &proc_res);
     }
 
@@ -82,8 +82,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     let expected_errors = errors::load_errors(&config.cfail_regex, testfile);
     if !expected_errors.is_empty() {
         if !props.error_patterns.is_empty() {
-            fatal("both error pattern and expected errors \
-                   specified".to_string());
+            fatal("both error pattern and expected errors specified");
         }
         check_expected_errors(expected_errors, testfile, &proc_res);
     } else {
@@ -97,7 +96,7 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         let proc_res = compile_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_proc_rec("compilation failed!".to_string(), &proc_res);
+            fatal_proc_rec("compilation failed!", &proc_res);
         }
 
         exec_compiled_test(config, props, testfile)
@@ -108,8 +107,7 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     // The value our Makefile configures valgrind to return on failure
     static VALGRIND_ERR: int = 100;
     if proc_res.status.matches_exit_status(VALGRIND_ERR) {
-        fatal_proc_rec("run-fail test isn't valgrind-clean!".to_string(),
-                      &proc_res);
+        fatal_proc_rec("run-fail test isn't valgrind-clean!", &proc_res);
     }
 
     check_correct_failure_status(&proc_res);
@@ -121,7 +119,8 @@ fn check_correct_failure_status(proc_res: &ProcRes) {
     static RUST_ERR: int = 101;
     if !proc_res.status.matches_exit_status(RUST_ERR) {
         fatal_proc_rec(
-            format!("failure produced the wrong error: {}", proc_res.status),
+            format!("failure produced the wrong error: {}",
+                    proc_res.status).as_slice(),
             proc_res);
     }
 }
@@ -131,19 +130,19 @@ fn run_rpass_test(config: &Config, props: &TestProps, testfile: &Path) {
         let mut proc_res = compile_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_proc_rec("compilation failed!".to_string(), &proc_res);
+            fatal_proc_rec("compilation failed!", &proc_res);
         }
 
         proc_res = exec_compiled_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_proc_rec("test run failed!".to_string(), &proc_res);
+            fatal_proc_rec("test run failed!", &proc_res);
         }
     } else {
         let proc_res = jit_test(config, props, testfile);
 
         if !proc_res.status.success() {
-            fatal_proc_rec("jit failed!".to_string(), &proc_res);
+            fatal_proc_rec("jit failed!", &proc_res);
         }
     }
 }
@@ -172,7 +171,8 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
                                     "normal");
 
         if !proc_res.status.success() {
-            fatal_proc_rec(format!("pretty-printing failed in round {}", round),
+            fatal_proc_rec(format!("pretty-printing failed in round {}",
+                                   round).as_slice(),
                           &proc_res);
         }
 
@@ -204,22 +204,20 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = typecheck_source(config, props, testfile, actual);
 
     if !proc_res.status.success() {
-        fatal_proc_rec("pretty-printed source does not typecheck".to_string(),
-                      &proc_res);
+        fatal_proc_rec("pretty-printed source does not typecheck", &proc_res);
     }
     if props.no_pretty_expanded { return }
 
     // additionally, run `--pretty expanded` and try to build it.
     let proc_res = print_source(config, props, testfile, (*srcs.get(round)).clone(), "expanded");
     if !proc_res.status.success() {
-        fatal_proc_rec(format!("pretty-printing (expanded) failed"), &proc_res);
+        fatal_proc_rec("pretty-printing (expanded) failed", &proc_res);
     }
 
     let ProcRes{ stdout: expanded_src, .. } = proc_res;
     let proc_res = typecheck_source(config, props, testfile, expanded_src);
     if !proc_res.status.success() {
-        fatal_proc_rec(format!("pretty-printed source (expanded) does \
-                               not typecheck"),
+        fatal_proc_rec("pretty-printed source (expanded) does not typecheck",
                       &proc_res);
     }
 
@@ -265,8 +263,7 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
 
     fn compare_source(expected: &str, actual: &str) {
         if expected != actual {
-            error("pretty-printed source does not match expected \
-                   source".to_string());
+            error("pretty-printed source does not match expected source");
             println!("\n\
 expected:\n\
 ------------------------------------------\n\
@@ -328,7 +325,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let compiler_run_result = compile_test(config, props, testfile);
     if !compiler_run_result.status.success() {
-        fatal_proc_rec("compilation failed!".to_string(), &compiler_run_result);
+        fatal_proc_rec("compilation failed!", &compiler_run_result);
     }
 
     let exe_file = make_exe_name(config, testfile);
@@ -412,7 +409,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
 
             let tool_path = match config.android_cross_path.as_str() {
                 Some(x) => x.to_string(),
-                None => fatal("cannot find android cross path".to_string())
+                None => fatal("cannot find android cross path")
             };
 
             let debugger_script = make_out_name(config, testfile, "debugger.script");
@@ -499,7 +496,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
     }
 
     if !debugger_run_result.status.success() {
-        fatal("gdb failed to execute".to_string());
+        fatal("gdb failed to execute");
     }
 
     check_debugger_output(&debugger_run_result, check_lines.as_slice());
@@ -509,8 +506,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     use std::io::process::{Command, ProcessOutput};
 
     if config.lldb_python_dir.is_none() {
-        fatal("Can't run LLDB test because LLDB's python path is not \
-               set.".to_string());
+        fatal("Can't run LLDB test because LLDB's python path is not set.");
     }
 
     let mut config = Config {
@@ -524,7 +520,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let compile_result = compile_test(config, props, testfile);
     if !compile_result.status.success() {
-        fatal_proc_rec("compilation failed!".to_string(), &compile_result);
+        fatal_proc_rec("compilation failed!", &compile_result);
     }
 
     let exe_file = make_exe_name(config, testfile);
@@ -567,8 +563,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     let debugger_run_result = run_lldb(config, &exe_file, &debugger_script);
 
     if !debugger_run_result.status.success() {
-        fatal_proc_rec("Error while running LLDB".to_string(),
-                      &debugger_run_result);
+        fatal_proc_rec("Error while running LLDB", &debugger_run_result);
     }
 
     check_debugger_output(&debugger_run_result, check_lines.as_slice());
@@ -592,7 +587,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
             },
             Err(e) => {
                 fatal(format!("Failed to setup Python process for \
-                               LLDB script: {}", e))
+                               LLDB script: {}", e).as_slice())
             }
         };
 
@@ -633,18 +628,19 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
 
                 header::parse_name_value_directive(
                         line.as_slice(),
-                        command_directive.to_string()).map(|cmd| {
+                        command_directive.as_slice()).map(|cmd| {
                     commands.push(cmd)
                 });
 
                 header::parse_name_value_directive(
                         line.as_slice(),
-                        check_directive.to_string()).map(|cmd| {
+                        check_directive.as_slice()).map(|cmd| {
                     check_lines.push(cmd)
                 });
             }
             Err(e) => {
-                fatal(format!("Error while parsing debugger commands: {}", e))
+                fatal(format!("Error while parsing debugger commands: {}",
+                              e).as_slice())
             }
         }
         counter += 1;
@@ -672,8 +668,7 @@ fn cleanup_debug_info_options(options: &Option<String>) -> Option<String> {
         split_maybe_args(options).move_iter()
                                  .filter(|x| !options_to_remove.contains(x))
                                  .collect::<Vec<String>>()
-                                 .connect(" ")
-                                 .to_string();
+                                 .connect(" ");
     Some(new_options)
 }
 
@@ -728,7 +723,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
         }
         if i != num_check_lines {
             fatal_proc_rec(format!("line not found in debugger output: {}",
-                                  check_lines.get(i).unwrap()),
+                                  check_lines.get(i).unwrap()).as_slice(),
                           debugger_run_result);
         }
     }
@@ -739,11 +734,11 @@ fn check_error_patterns(props: &TestProps,
                         proc_res: &ProcRes) {
     if props.error_patterns.is_empty() {
         fatal(format!("no error pattern specified in {}",
-                      testfile.display().as_maybe_owned().as_slice()));
+                      testfile.display()).as_slice());
     }
 
     if proc_res.status.success() {
-        fatal("process did not return an error status".to_string());
+        fatal("process did not return an error status");
     }
 
     let mut next_err_idx = 0u;
@@ -772,21 +767,21 @@ fn check_error_patterns(props: &TestProps,
         props.error_patterns.slice(next_err_idx, props.error_patterns.len());
     if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
-                              missing_patterns[0]),
+                              missing_patterns[0]).as_slice(),
                       proc_res);
     } else {
         for pattern in missing_patterns.iter() {
-            error(format!("error pattern '{}' not found!", *pattern));
+            error(format!("error pattern '{}' not found!",
+                          *pattern).as_slice());
         }
-        fatal_proc_rec("multiple error patterns not found".to_string(),
-                      proc_res);
+        fatal_proc_rec("multiple error patterns not found", proc_res);
     }
 }
 
 fn check_no_compiler_crash(proc_res: &ProcRes) {
     for line in proc_res.stderr.as_slice().lines() {
         if line.starts_with("error: internal compiler error:") {
-            fatal_proc_rec("compiler encountered internal error".to_string(),
+            fatal_proc_rec("compiler encountered internal error",
                           proc_res);
         }
     }
@@ -801,7 +796,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         expected_errors.len(), false);
 
     if proc_res.status.success() {
-        fatal("process did not return an error status".to_string());
+        fatal("process did not return an error status");
     }
 
     let prefixes = expected_errors.iter().map(|ee| {
@@ -865,7 +860,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
 
         if !was_expected && is_compiler_error_or_warning(line) {
             fatal_proc_rec(format!("unexpected compiler error or warning: '{}'",
-                                  line),
+                                  line).as_slice(),
                           proc_res);
         }
     }
@@ -874,7 +869,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
         if !flag {
             let ee = expected_errors.get(i);
             fatal_proc_rec(format!("expected {} on line {} not found: {}",
-                                  ee.kind, ee.line, ee.msg),
+                                  ee.kind, ee.line, ee.msg).as_slice(),
                           proc_res);
         }
     }
@@ -1059,7 +1054,7 @@ fn compose_and_run_compiler(
         if !auxres.status.success() {
             fatal_proc_rec(
                 format!("auxiliary build of {} failed to compile: ",
-                        abs_ab.display()),
+                        abs_ab.display()).as_slice(),
                 &auxres);
         }
 
@@ -1296,11 +1291,11 @@ fn maybe_dump_to_stdout(config: &Config, out: &str, err: &str) {
     }
 }
 
-fn error(err: String) { println!("\nerror: {}", err); }
+fn error(err: &str) { println!("\nerror: {}", err); }
 
-fn fatal(err: String) -> ! { error(err); fail!(); }
+fn fatal(err: &str) -> ! { error(err); fail!(); }
 
-fn fatal_proc_rec(err: String, proc_res: &ProcRes) -> ! {
+fn fatal_proc_rec(err: &str, proc_res: &ProcRes) -> ! {
     print!("\n\
 error: {}\n\
 status: {}\n\
@@ -1573,44 +1568,44 @@ fn run_codegen_test(config: &Config, props: &TestProps,
                     testfile: &Path, mm: &mut MetricMap) {
 
     if config.llvm_bin_path.is_none() {
-        fatal("missing --llvm-bin-path".to_string());
+        fatal("missing --llvm-bin-path");
     }
 
     if config.clang_path.is_none() {
-        fatal("missing --clang-path".to_string());
+        fatal("missing --clang-path");
     }
 
     let mut proc_res = compile_test_and_save_bitcode(config, props, testfile);
     if !proc_res.status.success() {
-        fatal_proc_rec("compilation failed!".to_string(), &proc_res);
+        fatal_proc_rec("compilation failed!", &proc_res);
     }
 
     proc_res = extract_function_from_bitcode(config, props, "test", testfile, "");
     if !proc_res.status.success() {
-        fatal_proc_rec("extracting 'test' function failed".to_string(),
+        fatal_proc_rec("extracting 'test' function failed",
                       &proc_res);
     }
 
     proc_res = disassemble_extract(config, props, testfile, "");
     if !proc_res.status.success() {
-        fatal_proc_rec("disassembling extract failed".to_string(), &proc_res);
+        fatal_proc_rec("disassembling extract failed", &proc_res);
     }
 
 
     let mut proc_res = compile_cc_with_clang_and_save_bitcode(config, props, testfile);
     if !proc_res.status.success() {
-        fatal_proc_rec("compilation failed!".to_string(), &proc_res);
+        fatal_proc_rec("compilation failed!", &proc_res);
     }
 
     proc_res = extract_function_from_bitcode(config, props, "test", testfile, "clang");
     if !proc_res.status.success() {
-        fatal_proc_rec("extracting 'test' function failed".to_string(),
+        fatal_proc_rec("extracting 'test' function failed",
                       &proc_res);
     }
 
     proc_res = disassemble_extract(config, props, testfile, "clang");
     if !proc_res.status.success() {
-        fatal_proc_rec("disassembling extract failed".to_string(), &proc_res);
+        fatal_proc_rec("disassembling extract failed", &proc_res);
     }
 
     let base = output_base_name(config, testfile);
diff --git a/src/compiletest/util.rs b/src/compiletest/util.rs
index 84bf0eb11553..c6e02606f74e 100644
--- a/src/compiletest/util.rs
+++ b/src/compiletest/util.rs
@@ -37,7 +37,7 @@ pub fn make_new_path(path: &str) -> String {
 
     // Windows just uses PATH as the library search path, so we have to
     // maintain the current value while adding our own
-    match getenv(lib_path_env_var().as_slice()) {
+    match getenv(lib_path_env_var()) {
       Some(curr) => {
         format!("{}{}{}", path, path_div(), curr)
       }
@@ -46,10 +46,10 @@ pub fn make_new_path(path: &str) -> String {
 }
 
 #[cfg(target_os = "win32")]
-pub fn lib_path_env_var() -> String { "PATH".to_string() }
+pub fn lib_path_env_var() -> &'static str { "PATH" }
 
 #[cfg(target_os = "win32")]
-pub fn path_div() -> String { ";".to_string() }
+pub fn path_div() -> &'static str { ";" }
 
 pub fn logv(config: &Config, s: String) {
     debug!("{}", s);