---

yaml
---
r: 114158
b: refs/heads/master
c: f2c4c88
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f853cf79b568fdffe83729aad4a43cb3c9ff3c92
+refs/heads/master: f2c4c88ff1236e381ec20f5444abe098b7873180
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/man/rustc.1

@@ -138,9 +138,6 @@ A space-separated list of arguments to pass through to LLVM.
 If specified, the compiler will save more files (.bc, .o, .no-opt.bc) generated
 throughout compilation in the output directory.
 .TP
-\fBandroid-cross-path\fR=path/to/ndk/bin
-Directory to find the Android NDK cross-compilation tools
-.TP
 \fBno-rpath\fR
 If specified, then the rpath value for dynamic libraries will not be set in
 either dynamic library or executable outputs.

trunk/mk/platform.mk

@@ -307,7 +307,7 @@ CFG_LDPATH_arm-linux-androideabi :=
 CFG_RUN_arm-linux-androideabi=
 CFG_RUN_TARG_arm-linux-androideabi=
 RUSTC_FLAGS_arm-linux-androideabi :=
-RUSTC_CROSS_FLAGS_arm-linux-androideabi :=-C android-cross-path=$(CFG_ANDROID_CROSS_PATH)
+RUSTC_CROSS_FLAGS_arm-linux-androideabi :=
 
 # arm-unknown-linux-gnueabihf configuration
 CROSS_PREFIX_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-

trunk/mk/tests.mk

@@ -601,6 +601,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
         --stage-id stage$(1)-$(2)							\
         --target $(2)                                       \
         --host $(3)                                       \
+        --android-cross-path=$(CFG_ANDROID_CROSS_PATH)    \
         --adb-path=$(CFG_ADB)                          \
         --adb-test-dir=$(CFG_ADB_TEST_DIR)                  \
         --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \

trunk/src/compiletest/common.rs

@@ -126,6 +126,9 @@ pub struct Config {
     // Host triple for the compiler being invoked
     pub host: ~str,
 
+    // Path to the android tools
+    pub android_cross_path: Path,
+
     // Extra parameter to run adb on arm-linux-androideabi
     pub adb_path: ~str,
 

trunk/src/compiletest/compiletest.rs

@@ -79,6 +79,7 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
           optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "host", "the host to build for", "HOST"),
+          optopt("", "android-cross-path", "Android NDK standalone path", "PATH"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
           optopt("", "lldb-python-dir", "directory containing LLDB's python module", "PATH"),
@@ -142,6 +143,7 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
         jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")).to_str(),
         host: opt_str2(matches.opt_str("host")).to_str(),
+        android_cross_path: opt_path(matches, "android-cross-path"),
         adb_path: opt_str2(matches.opt_str("adb-path")).to_str(),
         adb_test_dir:
             opt_str2(matches.opt_str("adb-test-dir")).to_str(),
@@ -150,7 +152,8 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
             "(none)" != opt_str2(matches.opt_str("adb-test-dir")) &&
             !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")),
+        test_shard: test::opt_shard(matches.opt_str("test-shard")
+                                           .map(|x| x.to_strbuf())),
         verbose: matches.opt_present("verbose")
     }
 }
@@ -173,6 +176,7 @@ pub fn log_config(config: &Config) {
     logv(c, format!("jit: {}", config.jit));
     logv(c, format!("target: {}", config.target));
     logv(c, format!("host: {}", config.host));
+    logv(c, format!("android-cross-path: {}", config.android_cross_path.display()));
     logv(c, format!("adb_path: {}", config.adb_path));
     logv(c, format!("adb_test_dir: {}", config.adb_test_dir));
     logv(c, format!("adb_device_status: {}", config.adb_device_status));
@@ -232,7 +236,10 @@ pub fn run_tests(config: &Config) {
 
 pub fn test_opts(config: &Config) -> test::TestOpts {
     test::TestOpts {
-        filter: config.filter.clone(),
+        filter: match config.filter {
+            None => None,
+            Some(ref filter) => Some(filter.to_strbuf()),
+        },
         run_ignored: config.run_ignored,
         logfile: config.logfile.clone(),
         run_tests: true,
@@ -311,7 +318,9 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
         format!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
     }
 
-    test::DynTestName(format!("[{}] {}", config.mode, shorten(testfile)))
+    test::DynTestName(format_strbuf!("[{}] {}",
+                                     config.mode,
+                                     shorten(testfile)))
 }
 
 pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {

trunk/src/compiletest/runtest.rs

@@ -347,18 +347,10 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 break;
             }
 
-            let args = split_maybe_args(&config.target_rustcflags);
-            let mut tool_path = StrBuf::new();
-            for arg in args.iter() {
-                if arg.contains("android-cross-path=") {
-                    tool_path = StrBuf::from_str(arg.replace("android-cross-path=", ""));
-                    break;
-                }
-            }
-
-            if tool_path.is_empty() {
-                fatal("cannot found android cross path".to_owned());
-            }
+            let tool_path = match config.android_cross_path.as_str() {
+                Some(x) => x.to_strbuf(),
+                None => fatal("cannot find android cross path".to_owned())
+            };
 
             let debugger_script = make_out_name(config, testfile, "debugger.script");
             // FIXME (#9639): This needs to handle non-utf8 paths

trunk/src/etc/zsh/_rust

@@ -5,7 +5,6 @@ local -a _rustc_opts_switches _rustc_opts_lint _rustc_opts_debug
 typeset -A opt_args
 
 _rustc_opts_switches=(
-    --android-cross-path'[The path to the Android NDK]'
     --ar'[Program to use for managing archives instead of the default.]'
     -c'[Compile and assemble, but do not link]'
     --cfg'[Configure the compilation environment]'

trunk/src/libarena/lib.rs

@@ -530,7 +530,7 @@ mod tests {
     }
 
     struct Noncopy {
-        string: ~str,
+        string: StrBuf,
         array: Vec<int> ,
     }
 
@@ -539,7 +539,7 @@ mod tests {
         let arena = TypedArena::new();
         for _ in range(0, 100000) {
             arena.alloc(Noncopy {
-                string: "hello world".to_owned(),
+                string: "hello world".to_strbuf(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             });
         }
@@ -550,7 +550,7 @@ mod tests {
         let arena = TypedArena::new();
         b.iter(|| {
             arena.alloc(Noncopy {
-                string: "hello world".to_owned(),
+                string: "hello world".to_strbuf(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             })
         })
@@ -560,7 +560,7 @@ mod tests {
     pub fn bench_noncopy_nonarena(b: &mut Bencher) {
         b.iter(|| {
             box Noncopy {
-                string: "hello world".to_owned(),
+                string: "hello world".to_strbuf(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             }
         })
@@ -571,7 +571,7 @@ mod tests {
         let arena = Arena::new();
         b.iter(|| {
             arena.alloc(|| Noncopy {
-                string: "hello world".to_owned(),
+                string: "hello world".to_strbuf(),
                 array: vec!( 1, 2, 3, 4, 5 ),
             })
         })

trunk/src/libcollections/hashmap.rs

@@ -1906,7 +1906,7 @@ mod test_map {
         }
         assert_eq!(m.len(), 32);
 
-        let mut observed = 0;
+        let mut observed: u32 = 0;
 
         for (k, v) in m.iter() {
             assert_eq!(*v, *k * 2);
@@ -2102,7 +2102,7 @@ mod test_set {
         for i in range(0u, 32) {
             assert!(a.insert(i));
         }
-        let mut observed = 0;
+        let mut observed: u32 = 0;
         for k in a.iter() {
             observed |= 1 << *k;
         }

trunk/src/libcollections/lru_cache.rs

@@ -270,23 +270,23 @@ mod tests {
 
     #[test]
     fn test_put_update() {
-        let mut cache: LruCache<~str, Vec<u8>> = LruCache::new(1);
-        cache.put("1".to_owned(), vec![10, 10]);
-        cache.put("1".to_owned(), vec![10, 19]);
-        assert_opt_eq(cache.get(&"1".to_owned()), vec![10, 19]);
+        let mut cache: LruCache<StrBuf, Vec<u8>> = LruCache::new(1);
+        cache.put("1".to_strbuf(), vec![10, 10]);
+        cache.put("1".to_strbuf(), vec![10, 19]);
+        assert_opt_eq(cache.get(&"1".to_strbuf()), vec![10, 19]);
         assert_eq!(cache.len(), 1);
     }
 
     #[test]
     fn test_expire_lru() {
-        let mut cache: LruCache<~str, ~str> = LruCache::new(2);
-        cache.put("foo1".to_owned(), "bar1".to_owned());
-        cache.put("foo2".to_owned(), "bar2".to_owned());
-        cache.put("foo3".to_owned(), "bar3".to_owned());
-        assert!(cache.get(&"foo1".to_owned()).is_none());
-        cache.put("foo2".to_owned(), "bar2update".to_owned());
-        cache.put("foo4".to_owned(), "bar4".to_owned());
-        assert!(cache.get(&"foo3".to_owned()).is_none());
+        let mut cache: LruCache<StrBuf, StrBuf> = LruCache::new(2);
+        cache.put("foo1".to_strbuf(), "bar1".to_strbuf());
+        cache.put("foo2".to_strbuf(), "bar2".to_strbuf());
+        cache.put("foo3".to_strbuf(), "bar3".to_strbuf());
+        assert!(cache.get(&"foo1".to_strbuf()).is_none());
+        cache.put("foo2".to_strbuf(), "bar2update".to_strbuf());
+        cache.put("foo4".to_strbuf(), "bar4".to_strbuf());
+        assert!(cache.get(&"foo3".to_strbuf()).is_none());
     }
 
     #[test]

trunk/src/libcore/cmp.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -217,6 +217,29 @@ mod impls {
     }
     impl<'a, T: TotalEq> TotalEq for &'a T {}
 
+    // &mut pointers
+    impl<'a, T: Eq> Eq for &'a mut T {
+        #[inline]
+        fn eq(&self, other: &&'a mut T) -> bool { **self == *(*other) }
+        #[inline]
+        fn ne(&self, other: &&'a mut T) -> bool { **self != *(*other) }
+    }
+    impl<'a, T: Ord> Ord for &'a mut T {
+        #[inline]
+        fn lt(&self, other: &&'a mut T) -> bool { **self < **other }
+        #[inline]
+        fn le(&self, other: &&'a mut T) -> bool { **self <= **other }
+        #[inline]
+        fn ge(&self, other: &&'a mut T) -> bool { **self >= **other }
+        #[inline]
+        fn gt(&self, other: &&'a mut T) -> bool { **self > **other }
+    }
+    impl<'a, T: TotalOrd> TotalOrd for &'a mut T {
+        #[inline]
+        fn cmp(&self, other: &&'a mut T) -> Ordering { (**self).cmp(*other) }
+    }
+    impl<'a, T: TotalEq> TotalEq for &'a mut T {}
+
     // @ pointers
     impl<T:Eq> Eq for @T {
         #[inline]
@@ -254,6 +277,15 @@ mod test {
         assert_eq!(12u.cmp(-5), Greater);
     }
 
+    #[test]
+    fn test_mut_int_totalord() {
+        assert_eq!((&mut 5u).cmp(&10), Less);
+        assert_eq!((&mut 10u).cmp(&5), Greater);
+        assert_eq!((&mut 5u).cmp(&5), Equal);
+        assert_eq!((&mut -5u).cmp(&12), Less);
+        assert_eq!((&mut 12u).cmp(-5), Greater);
+    }
+
     #[test]
     fn test_ordering_order() {
         assert!(Less < Equal);

trunk/src/libglob/lib.rs

@@ -310,7 +310,7 @@ impl Pattern {
      * brackets. The resulting string will, when compiled into a `Pattern`,
      * match the input string and nothing else.
      */
-    pub fn escape(s: &str) -> ~str {
+    pub fn escape(s: &str) -> StrBuf {
         let mut escaped = StrBuf::new();
         for c in s.chars() {
             match c {
@@ -325,7 +325,7 @@ impl Pattern {
                 }
             }
         }
-        escaped.into_owned()
+        escaped
     }
 
     /**
@@ -767,8 +767,8 @@ mod test {
     #[test]
     fn test_pattern_escape() {
         let s = "_[_]_?_*_!_";
-        assert_eq!(Pattern::escape(s), "_[[]_[]]_[?]_[*]_!_".to_owned());
-        assert!(Pattern::new(Pattern::escape(s)).matches(s));
+        assert_eq!(Pattern::escape(s), "_[[]_[]]_[?]_[*]_!_".to_strbuf());
+        assert!(Pattern::new(Pattern::escape(s).as_slice()).matches(s));
     }
 
     #[test]

trunk/src/libgraphviz/lib.rs

@@ -433,10 +433,10 @@ impl<'a> LabelText<'a> {
     }
 
     /// Renders text as string suitable for a label in a .dot file.
-    pub fn escape(&self) -> ~str {
+    pub fn escape(&self) -> StrBuf {
         match self {
-            &LabelStr(ref s) => s.as_slice().escape_default(),
-            &EscStr(ref s) => LabelText::escape_str(s.as_slice()).into_owned(),
+            &LabelStr(ref s) => s.as_slice().escape_default().to_strbuf(),
+            &EscStr(ref s) => LabelText::escape_str(s.as_slice()).to_strbuf(),
         }
     }
 }
@@ -661,11 +661,14 @@ mod tests {
         }
     }
 
-    fn test_input(g: LabelledGraph) -> IoResult<~str> {
+    fn test_input(g: LabelledGraph) -> IoResult<StrBuf> {
         let mut writer = MemWriter::new();
         render(&g, &mut writer).unwrap();
         let mut r = BufReader::new(writer.get_ref());
-        r.read_to_str()
+        match r.read_to_str() {
+            Ok(string) => Ok(string.to_strbuf()),
+            Err(err) => Err(err),
+        }
     }
 
     // All of the tests use raw-strings as the format for the expected outputs,

trunk/src/libhexfloat/lib.rs

@@ -70,30 +70,39 @@ pub fn macro_registrar(register: |Name, SyntaxExtension|) {
 
 //Check if the literal is valid (as LLVM expects),
 //and return a descriptive error if not.
-fn hex_float_lit_err(s: &str) -> Option<(uint, ~str)> {
+fn hex_float_lit_err(s: &str) -> Option<(uint, StrBuf)> {
     let mut chars = s.chars().peekable();
     let mut i = 0;
     if chars.peek() == Some(&'-') { chars.next(); i+= 1 }
-    if chars.next() != Some('0') { return Some((i, "Expected '0'".to_owned())); } i+=1;
-    if chars.next() != Some('x') { return Some((i, "Expected 'x'".to_owned())); } i+=1;
+    if chars.next() != Some('0') {
+        return Some((i, "Expected '0'".to_strbuf()));
+    } i+=1;
+    if chars.next() != Some('x') {
+        return Some((i, "Expected 'x'".to_strbuf()));
+    } i+=1;
     let mut d_len = 0;
     for _ in chars.take_while(|c| c.is_digit_radix(16)) { chars.next(); i+=1; d_len += 1;}
-    if chars.next() != Some('.') { return Some((i, "Expected '.'".to_owned())); } i+=1;
+    if chars.next() != Some('.') {
+        return Some((i, "Expected '.'".to_strbuf()));
+    } i+=1;
     let mut f_len = 0;
     for _ in chars.take_while(|c| c.is_digit_radix(16)) { chars.next(); i+=1; f_len += 1;}
     if d_len == 0 && f_len == 0 {
-        return Some((i, "Expected digits before or after decimal point".to_owned()));
+        return Some((i, "Expected digits before or after decimal \
+                         point".to_strbuf()));
     }
-    if chars.next() != Some('p') { return Some((i, "Expected 'p'".to_owned())); } i+=1;
+    if chars.next() != Some('p') {
+        return Some((i, "Expected 'p'".to_strbuf()));
+    } i+=1;
     if chars.peek() == Some(&'-') { chars.next(); i+= 1 }
     let mut e_len = 0;
     for _ in chars.take_while(|c| c.is_digit()) { chars.next(); i+=1; e_len += 1}
     if e_len == 0 {
-        return Some((i, "Expected exponent digits".to_owned()));
+        return Some((i, "Expected exponent digits".to_strbuf()));
     }
     match chars.next() {
         None => None,
-        Some(_) => Some((i, "Expected end of string".to_owned()))
+        Some(_) => Some((i, "Expected end of string".to_strbuf()))
     }
 }