---

yaml
---
r: 58182
b: refs/heads/auto
c: 45ae340
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 6bcc3a6c5742b5436d0c7f8be4bfb79f7eacd760
+refs/heads/auto: 45ae3402e034e83d254d1bc36914f8433202bad9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/mk/install.mk

@@ -192,9 +192,9 @@ ifeq ($(CFG_ADB_DEVICE_STATUS),true)
 ifdef VERBOSE
  ADB = adb $(1)
  ADB_PUSH = adb push $(1) $(2)
- ADB_SHELL = adb shell $(1) $(2) 
+ ADB_SHELL = adb shell $(1) $(2)
 else
- ADB = $(Q)$(call E, adb $(1)) && adb $(1) 1>/dev/null 
+ ADB = $(Q)$(call E, adb $(1)) && adb $(1) 1>/dev/null
  ADB_PUSH = $(Q)$(call E, adb push $(1)) && adb push $(1) $(2) 1>/dev/null
  ADB_SHELL = $(Q)$(call E, adb shell $(1) $(2)) && adb shell $(1) $(2) 1>/dev/null
 endif
@@ -222,8 +222,8 @@ install-runtime-target: \
 	install-runtime-target-arm-linux-androideabi-cleanup \
 	install-runtime-target-arm-linux-androideabi-host-$(CFG_BUILD_TRIPLE)
 else
-install-runtime-target: 
+install-runtime-target:
 	@echo "No device to install runtime library"
-	@echo 
+	@echo
 endif
 endif

branches/auto/mk/tests.mk

@@ -92,7 +92,7 @@ endef
 $(foreach target,$(CFG_TARGET_TRIPLES), \
   $(eval $(call DEF_TARGET_COMMANDS,$(target))))
 
-# Target platform specific variables 
+# Target platform specific variables
 # for arm-linux-androidabi
 define DEF_ADB_DEVICE_STATUS
 CFG_ADB_DEVICE_STATUS=$(1)
@@ -402,7 +402,7 @@ $(foreach host,$(CFG_HOST_TRIPLES), \
        $(eval $(call DEF_TEST_CRATE_RULES_null,$(stage),$(target),$(host),$(crate))) \
       ), \
       $(eval $(call DEF_TEST_CRATE_RULES,$(stage),$(target),$(host),$(crate))) \
-     )))))) 
+     ))))))
 
 
 ######################################################################

branches/auto/src/libcore/hashmap.rs

@@ -352,16 +352,27 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
     }
 
     /// Return a mutable reference to the value corresponding to the key
+    #[cfg(stage0)]
     fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> {
         let idx = match self.bucket_for_key(k) {
             FoundEntry(idx) => idx,
             TableFull | FoundHole(_) => return None
         };
-        unsafe {  // FIXME(#4903)---requires flow-sensitive borrow checker
+        unsafe {
             Some(::cast::transmute_mut_region(self.mut_value_for_bucket(idx)))
         }
     }
 
+    /// Return a mutable reference to the value corresponding to the key
+    #[cfg(not(stage0))]
+    fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> {
+        let idx = match self.bucket_for_key(k) {
+            FoundEntry(idx) => idx,
+            TableFull | FoundHole(_) => return None
+        };
+        Some(self.mut_value_for_bucket(idx))
+    }
+
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
@@ -424,6 +435,7 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
 
     /// Return the value corresponding to the key in the map, or insert
     /// and return the value if it doesn't exist.
+    #[cfg(stage0)]
     fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
@@ -447,13 +459,43 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
             },
         };
 
-        unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
+        unsafe {
             ::cast::transmute_region(self.value_for_bucket(idx))
         }
     }
 
+    /// Return the value corresponding to the key in the map, or insert
+    /// and return the value if it doesn't exist.
+    #[cfg(not(stage0))]
+    fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {
+        if self.size >= self.resize_at {
+            // n.b.: We could also do this after searching, so
+            // that we do not resize if this call to insert is
+            // simply going to update a key in place.  My sense
+            // though is that it's worse to have to search through
+            // buckets to find the right spot twice than to just
+            // resize in this corner case.
+            self.expand();
+        }
+
+        let hash = k.hash_keyed(self.k0, self.k1) as uint;
+        let idx = match self.bucket_for_key_with_hash(hash, &k) {
+            TableFull => fail!(~"Internal logic error"),
+            FoundEntry(idx) => idx,
+            FoundHole(idx) => {
+                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
+                                     value: v});
+                self.size += 1;
+                idx
+            },
+        };
+
+        self.value_for_bucket(idx)
+    }
+
     /// Return the value corresponding to the key in the map, or create,
     /// insert, and return a new value if it doesn't exist.
+    #[cfg(stage0)]
     fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V) -> &'a V {
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
@@ -478,11 +520,41 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
             },
         };
 
-        unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
+        unsafe {
             ::cast::transmute_region(self.value_for_bucket(idx))
         }
     }
 
+    /// Return the value corresponding to the key in the map, or create,
+    /// insert, and return a new value if it doesn't exist.
+    #[cfg(not(stage0))]
+    fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V) -> &'a V {
+        if self.size >= self.resize_at {
+            // n.b.: We could also do this after searching, so
+            // that we do not resize if this call to insert is
+            // simply going to update a key in place.  My sense
+            // though is that it's worse to have to search through
+            // buckets to find the right spot twice than to just
+            // resize in this corner case.
+            self.expand();
+        }
+
+        let hash = k.hash_keyed(self.k0, self.k1) as uint;
+        let idx = match self.bucket_for_key_with_hash(hash, &k) {
+            TableFull => fail!(~"Internal logic error"),
+            FoundEntry(idx) => idx,
+            FoundHole(idx) => {
+                let v = f(&k);
+                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
+                                     value: v});
+                self.size += 1;
+                idx
+            },
+        };
+
+        self.value_for_bucket(idx)
+    }
+
     fn consume(&mut self, f: &fn(K, V)) {
         let mut buckets = ~[];
         self.buckets <-> buckets;

branches/auto/src/libcore/task/local_data.rs

@@ -215,12 +215,3 @@ fn test_tls_cleanup_on_failure() {
         fail!();
     }
 }
-
-#[test]
-fn test_static_pointer() {
-    unsafe {
-        fn key(_x: @&'static int) { }
-        static VALUE: int = 0;
-        local_data_set(key, @&VALUE);
-    }
-}

branches/auto/src/libcore/trie.rs

@@ -289,9 +289,9 @@ fn chunk(n: uint, idx: uint) -> uint {
     (n >> sh) & MASK
 }
 
-fn find_mut<'r, T>(child: &'r mut Child<T>, key: uint, idx: uint)
-                -> Option<&'r mut T> {
-    unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
+#[cfg(stage0)]
+fn find_mut<'r, T>(child: &'r mut Child<T>, key: uint, idx: uint) -> Option<&'r mut T> {
+    unsafe {
         (match *child {
             External(_, ref value) => Some(cast::transmute_mut(value)),
             Internal(ref x) => find_mut(cast::transmute_mut(&x.children[chunk(key, idx)]),
@@ -301,6 +301,15 @@ fn find_mut<'r, T>(child: &'r mut Child<T>, key: uint, idx: uint)
     }
 }
 
+#[cfg(not(stage0))]
+fn find_mut<'r, T>(child: &'r mut Child<T>, key: uint, idx: uint) -> Option<&'r mut T> {
+    match *child {
+        External(_, ref mut value) => Some(value),
+        Internal(ref mut x) => find_mut(&mut x.children[chunk(key, idx)], key, idx + 1),
+        Nothing => None
+    }
+}
+
 fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
              idx: uint) -> Option<T> {
     let mut tmp = Nothing;

branches/auto/src/libcore/vec.rs

@@ -991,7 +991,7 @@ pub fn connect<T:Copy>(v: &[~[T]], sep: &T) -> ~[T] {
  * ~~~
  *
  */
-pub fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T {
+pub fn foldl<'a, T, U>(z: T, v: &'a [U], p: &fn(t: T, u: &'a U) -> T) -> T {
     let mut accum = z;
     let mut i = 0;
     let l = v.len();
@@ -1023,12 +1023,13 @@ pub fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T {
  * ~~~
  *
  */
-pub fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U {
-    let mut accum = z;
-    for v.each_reverse |elt| {
-        accum = p(elt, accum);
+pub fn foldr<'a, T, U>(v: &'a [T], mut z: U, p: &fn(t: &'a T, u: U) -> U) -> U {
+    let mut i = v.len();
+    while i > 0 {
+        i -= 1;
+        z = p(&v[i], z);
     }
-    accum
+    return z;
 }
 
 /**
@@ -1848,7 +1849,7 @@ pub trait ImmutableVector<'self, T> {
     fn last_opt(&self) -> Option<&'self T>;
     fn each_reverse(&self, blk: &fn(&T) -> bool);
     fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool);
-    fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U;
+    fn foldr<'a, U>(&'a self, z: U, p: &fn(t: &'a T, u: U) -> U) -> U;
     fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
     fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
     fn map_r<U>(&self, f: &fn(x: &T) -> U) -> ~[U];
@@ -1921,7 +1922,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
 
     /// Reduce a vector from right to left
     #[inline]
-    fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U {
+    fn foldr<'a, U>(&'a self, z: U, p: &fn(t: &'a T, u: U) -> U) -> U {
         foldr(*self, z, p)
     }
 
@@ -3304,7 +3305,7 @@ mod tests {
     }
 
     #[test]
-    fn test_iter_nonempty() {
+    fn test_each_nonempty() {
         let mut i = 0;
         for each(~[1, 2, 3]) |v| {
             i += *v;
@@ -3313,7 +3314,7 @@ mod tests {
     }
 
     #[test]
-    fn test_iteri() {
+    fn test_eachi() {
         let mut i = 0;
         for eachi(~[1, 2, 3]) |j, v| {
             if i == 0 { assert!(*v == 1); }

branches/auto/src/test/compile-fail/core-tls-store-pointer.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// xfail-test
 struct Obj {
     member: uint
 }
@@ -17,8 +16,8 @@ pub impl Obj {
     fn boom() -> bool {
         return 1+1 == 2
     }
-    fn chirp() {
-        self.boom(); //~ ERROR wat
+    fn chirp(&self) {
+        self.boom(); //~ ERROR `&Obj` does not implement any method in scope named `boom`
     }
 }