---

yaml
---
r: 65438
b: refs/heads/master
c: 7f410b3
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c492a2126fddb1b844ddee05a283a92329c6c041
+refs/heads/master: 7f410b326cef0939f581dcb7a469680b3c9c98b2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/configure

@@ -970,6 +970,13 @@ then
     putvar CFG_CCACHE_CPP2
 fi
 
+if [ ! -z "$CFG_ENABLE_CCACHE" ]
+then
+    CFG_CCACHE_BASEDIR=${CFG_SRC_DIR}
+    putvar CFG_CCACHE_BASEDIR
+fi
+
+
 if [ ! -z $BAD_PANDOC ]
 then
     CFG_PANDOC=

trunk/mk/platform.mk

@@ -396,6 +396,11 @@ ifeq ($(CFG_CCACHE_CPP2),1)
   export CCACHE_CPP
 endif
 
+ifdef CFG_CCACHE_BASEDIR
+  CCACHE_BASEDIR=$(CFG_CCACHE_BASEDIR)
+  export CCACHE_BASEDIR
+endif
+
 define CFG_MAKE_TOOLCHAIN
   CFG_COMPILE_C_$(1) = $$(CC_$(1))  \
         $$(CFG_GCCISH_CFLAGS)      \

trunk/src/compiletest/header.rs

@@ -99,7 +99,7 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     return false;
 
     fn xfail_target() -> ~str {
-        ~"xfail-" + os::SYSNAME
+        ~"xfail-" + str::to_owned(os::SYSNAME)
     }
 }
 
@@ -173,7 +173,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
 
 fn parse_name_value_directive(line: &str,
                               directive: ~str) -> Option<~str> {
-    let keycolon = directive + ":";
+    let keycolon = directive + ~":";
     match str::find_str(line, keycolon) {
         Some(colon) => {
             let value = str::slice(line, colon + str::len(keycolon),

trunk/src/compiletest/procsrv.rs

@@ -24,12 +24,12 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
     let mut env = os::env();
 
     // Make sure we include the aux directory in the path
-    assert!(prog.ends_with(".exe"));
-    let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ".libaux";
+    assert!(prog.ends_with(~".exe"));
+    let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ~".libaux";
 
     env = do vec::map(env) |pair| {
         let (k,v) = *pair;
-        if k == ~"PATH" { (~"PATH", v + ";" + lib_path + ";" + aux_path) }
+        if k == ~"PATH" { (~"PATH", v + ~";" + lib_path + ~";" + aux_path) }
         else { (k,v) }
     };
     if str::ends_with(prog, "rustc.exe") {

trunk/src/compiletest/runtest.rs

@@ -378,7 +378,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
             was_expected = true;
         }
 
-        if !was_expected && is_compiler_error_or_warning(line) {
+        if !was_expected && is_compiler_error_or_warning(str::to_owned(line)) {
             fatal_ProcRes(fmt!("unexpected compiler error or warning: '%s'",
                                line),
                           ProcRes);
@@ -596,7 +596,8 @@ fn make_lib_name(config: &config, auxfile: &Path, testfile: &Path) -> Path {
 }
 
 fn make_exe_name(config: &config, testfile: &Path) -> Path {
-    Path(output_base_name(config, testfile).to_str() + os::EXE_SUFFIX)
+    Path(output_base_name(config, testfile).to_str() +
+            str::to_owned(os::EXE_SUFFIX))
 }
 
 fn make_run_args(config: &config, _props: &TestProps, testfile: &Path) ->
@@ -605,7 +606,7 @@ fn make_run_args(config: &config, _props: &TestProps, testfile: &Path) ->
     // then split apart its command
     let toolargs = split_maybe_args(&config.runtool);
 
-    let mut args = toolargs + [make_exe_name(config, testfile).to_str()];
+    let mut args = toolargs + ~[make_exe_name(config, testfile).to_str()];
     let prog = args.shift();
     return ProcArgs {prog: prog, args: args};
 }
@@ -654,7 +655,7 @@ fn make_cmdline(_libpath: &str, prog: &str, args: &[~str]) -> ~str {
 #[cfg(target_os = "win32")]
 fn make_cmdline(libpath: &str, prog: &str, args: &[~str]) -> ~str {
     fmt!("%s %s %s", lib_path_cmd_prefix(libpath), prog,
-         str::connect(args, " "))
+         str::connect(args, ~" "))
 }
 
 // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
@@ -775,8 +776,8 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     for args.args.each |tv| {
         newcmd_out.push_str(" ");
         newcmd_err.push_str(" ");
-        newcmd_out.push_str(*tv);
-        newcmd_err.push_str(*tv);
+        newcmd_out.push_str(tv.to_owned());
+        newcmd_err.push_str(tv.to_owned());
     }
 
     newcmd_out.push_str(" 2>/dev/null");

trunk/src/libextra/getopts.rs

@@ -110,11 +110,10 @@ pub struct Opt {
 }
 
 fn mkname(nm: &str) -> Name {
-  if nm.len() == 1u {
-      Short(str::char_at(nm, 0u))
-  } else {
-      Long(nm.to_owned())
-  }
+    let unm = str::to_owned(nm);
+    return if nm.len() == 1u {
+            Short(str::char_at(unm, 0u))
+        } else { Long(unm) };
 }
 
 /// Create an option that is required and takes an argument
@@ -196,19 +195,19 @@ pub enum Fail_ {
 pub fn fail_str(f: Fail_) -> ~str {
     return match f {
         ArgumentMissing(ref nm) => {
-            fmt!("Argument to option '%s' missing.", *nm)
+            ~"Argument to option '" + *nm + "' missing."
         }
         UnrecognizedOption(ref nm) => {
-            fmt!("Unrecognized option: '%s'.", *nm)
+            ~"Unrecognized option: '" + *nm + "'."
         }
         OptionMissing(ref nm) => {
-            fmt!("Required option '%s' missing.", *nm)
+            ~"Required option '" + *nm + "' missing."
         }
         OptionDuplicated(ref nm) => {
-            fmt!("Option '%s' given more than once.", *nm)
+            ~"Option '" + *nm + "' given more than once."
         }
         UnexpectedArgument(ref nm) => {
-            fmt!("Option '%s' does not take an argument.", *nm)
+            ~"Option " + *nm + " does not take an argument."
         }
     };
 }
@@ -246,11 +245,11 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
             let mut names;
             let mut i_arg = None;
             if cur[1] == '-' as u8 {
-                let tail = str::slice(cur, 2, curlen);
+                let tail = str::slice(cur, 2, curlen).to_owned();
                 let mut tail_eq = ~[];
                 for str::each_splitn_char(tail, '=', 1) |s| { tail_eq.push(s.to_owned()) }
                 if tail_eq.len() <= 1 {
-                    names = ~[Long(tail.to_owned())];
+                    names = ~[Long(tail)];
                 } else {
                     names =
                         ~[Long(copy tail_eq[0])];

trunk/src/libextra/net_ip.rs

@@ -230,7 +230,7 @@ pub mod v4 {
             let input_is_inaddr_none =
                 result::get(&ip_rep_result).as_u32() == INADDR_NONE;
 
-            let new_addr = uv_ip4_addr(ip, 22);
+            let new_addr = uv_ip4_addr(str::to_owned(ip), 22);
             let reformatted_name = uv_ip4_name(&new_addr);
             debug!("try_parse_addr: input ip: %s reparsed ip: %s",
                             ip, reformatted_name);
@@ -259,6 +259,7 @@ pub mod v6 {
     use uv_ip6_name = uv::ll::ip6_name;
 
     use core::result;
+    use core::str;
 
     /**
      * Convert a str to `ip_addr`
@@ -284,7 +285,7 @@ pub mod v6 {
     pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
         unsafe {
             // need to figure out how to establish a parse failure..
-            let new_addr = uv_ip6_addr(ip, 22);
+            let new_addr = uv_ip6_addr(str::to_owned(ip), 22);
             let reparsed_name = uv_ip6_name(&new_addr);
             debug!("v6::try_parse_addr ip: '%s' reparsed '%s'",
                             ip, reparsed_name);

trunk/src/libextra/net_url.rs

@@ -585,7 +585,7 @@ fn get_path(rawurl: &str, authority: bool) ->
         }
     }
 
-    return Ok((decode_component(str::slice(rawurl, 0, end)),
+    return Ok((decode_component(str::slice(rawurl, 0, end).to_owned()),
                     str::slice(rawurl, end, len).to_owned()));
 }
 
@@ -596,13 +596,14 @@ fn get_query_fragment(rawurl: &str) ->
         if str::starts_with(rawurl, "#") {
             let f = decode_component(str::slice(rawurl,
                                                 1,
-                                                str::len(rawurl)));
+                                                str::len(rawurl)).to_owned());
             return Ok((~[], Some(f)));
         } else {
             return Ok((~[], None));
         }
     }
-    let (q, r) = split_char_first(str::slice(rawurl, 1, rawurl.len()), '#');
+    let (q, r) = split_char_first(str::slice(rawurl, 1,
+                                             str::len(rawurl)).to_owned(), '#');
     let f = if str::len(r) != 0 {
         Some(decode_component(r)) } else { None };
     return Ok((query_from_str(q), f));

trunk/src/libextra/sha1.rs

@@ -399,7 +399,8 @@ mod tests {
             let mut left = len;
             while left > 0u {
                 let take = (left + 1u) / 2u;
-                sh.input_str(t.input.slice(len - left, take + len - left));
+                sh.input_str(str::slice(t.input, len - left,
+                             take + len - left).to_owned());
                 left = left - take;
             }
             let out = sh.result();

trunk/src/libextra/time.rs

@@ -293,7 +293,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
 
         let mut i = 0u;
         while i < digits {
-            let range = str::char_range_at(ss, pos);
+            let range = str::char_range_at(str::to_owned(ss), pos);
             pos = range.next;
 
             match range.ch {
@@ -632,7 +632,7 @@ priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
         }
     }
 
-    do io::with_str_reader(format) |rdr| {
+    do io::with_str_reader(str::to_owned(format)) |rdr| {
         let mut tm = Tm {
             tm_sec: 0_i32,
             tm_min: 0_i32,
@@ -844,7 +844,7 @@ priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
 
     let mut buf = ~"";
 
-    do io::with_str_reader(format) |rdr| {
+    do io::with_str_reader(str::to_owned(format)) |rdr| {
         while !rdr.eof() {
             match rdr.read_char() {
                 '%' => buf += parse_type(rdr.read_char(), tm),

trunk/src/libextra/workcache.rs

@@ -201,7 +201,7 @@ struct Logger {
 
 pub impl Logger {
     fn info(&self, i: &str) {
-        io::println(~"workcache: " + i);
+        io::println(~"workcache: " + i.to_owned());
     }
 }
 

trunk/src/librustc/back/link.rs

@@ -741,14 +741,16 @@ pub fn mangle_internal_name_by_seq(ccx: @CrateContext, flav: &str) -> ~str {
 
 
 pub fn output_dll_filename(os: session::os, lm: LinkMeta) -> ~str {
+    let libname = fmt!("%s-%s-%s", lm.name, lm.extras_hash, lm.vers);
     let (dll_prefix, dll_suffix) = match os {
         session::os_win32 => (win32::DLL_PREFIX, win32::DLL_SUFFIX),
         session::os_macos => (macos::DLL_PREFIX, macos::DLL_SUFFIX),
         session::os_linux => (linux::DLL_PREFIX, linux::DLL_SUFFIX),
         session::os_android => (android::DLL_PREFIX, android::DLL_SUFFIX),
         session::os_freebsd => (freebsd::DLL_PREFIX, freebsd::DLL_SUFFIX),
     };
-    fmt!("%s%s-%s-%s%s", dll_prefix, lm.name, lm.extras_hash, lm.vers, dll_suffix)
+    return str::to_owned(dll_prefix) + libname +
+           str::to_owned(dll_suffix);
 }
 
 // If the user wants an exe generated we need to invoke

trunk/src/librustc/lib/llvm.rs

@@ -2014,7 +2014,7 @@ pub fn type_to_str_inner(names: @TypeNames, outer0: &[TypeRef], ty: TypeRef)
             let mut first: bool = true;
             for tys.each |t| {
                 if first { first = false; } else { s += ", "; }
-                s += type_to_str_inner(names, outer, *t);
+                s += type_to_str_inner(names, outer, *t).to_owned();
             }
             // [Note at-str] FIXME #2543: Could rewrite this without the copy,
             // but need better @str support.

trunk/src/librustc/metadata/loader.rs

@@ -268,7 +268,8 @@ pub fn list_file_metadata(intr: @ident_interner,
     match get_metadata_section(os, path) {
       option::Some(bytes) => decoder::list_crate_metadata(intr, bytes, out),
       option::None => {
-        out.write_str(fmt!("could not find metadata in %s.\n", path.to_str()))
+        out.write_str(~"could not find metadata in "
+                      + path.to_str() + ".\n");
       }
     }
 }

trunk/src/librustc/metadata/tyencode.rs

@@ -89,7 +89,8 @@ pub fn enc_ty(w: @io::Writer, cx: @ctxt, t: ty::t) {
           let abbrev_len = 3u + estimate_sz(pos) + estimate_sz(len);
           if abbrev_len < len {
               // I.e. it's actually an abbreviation.
-              let s = fmt!("#%x:%x#", pos, len);
+              let s = ~"#" + uint::to_str_radix(pos, 16u) + ":" +
+                  uint::to_str_radix(len, 16u) + "#";
               let a = ty_abbrev { pos: pos, len: len, s: @s };
               abbrevs.insert(t, a);
           }