---

yaml
---
r: 104541
b: refs/heads/try
c: 818203e
h: refs/heads/master
i:
  104539: 69e8018
v: v3

Author: eddyb

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: fc1c06d7b1202a0cc7c09bcfeca88ada3fbfb091
+refs/heads/try: 818203e9d25f99cb6fcdf7210c512bfb09f0956f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/index.md

@@ -43,7 +43,6 @@ li {list-style-type: none; }
 * [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html)
 * [The `syntax` library, the Rust parser](syntax/index.html)
 * [The `term` terminal-handling library](term/index.html)
-* [The `test` library](test/index.html)
 * [The `uuid` 128-bit universally unique identifier library](uuid/index.html)
 
 # Tooling

branches/try/src/libgreen/sched.rs

@@ -1394,6 +1394,8 @@ mod test {
         });
     }
 
+    // FIXME: #9407: ignore-test
+    #[ignore]
     #[test]
     fn dont_starve_1() {
         let mut pool = SchedPool::new(PoolConfig {

branches/try/src/librustc/middle/typeck/check/mod.rs

@@ -2087,18 +2087,6 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
         };
         check_expr(fcx, rhs);
 
-        // If the or operator is used it might be that the user forgot to
-        // supply the do keyword.  Let's be more helpful in that situation.
-        if op == ast::BiOr {
-            match ty::get(lhs_resolved_t).sty {
-                ty::ty_bare_fn(_) | ty::ty_closure(_) => {
-                    tcx.sess.span_note(
-                        ex.span, "did you forget the `do` keyword for the call?");
-                }
-                _ => ()
-            }
-        }
-
         ty::mk_err()
     }
 

branches/try/src/libstd/rt/crate_map.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use cast;
 use cmp::TotalOrd;
 use container::MutableSet;
 use iter::Iterator;
@@ -36,61 +35,27 @@ pub struct CrateMap<'a> {
     event_loop_factory: Option<fn() -> ~EventLoop>,
 }
 
-// When working on android, apparently weak symbols don't work so well for
-// finding the crate map, and neither does dlopen + dlsym. This is mainly a
-// problem when integrating a shared library with an existing application.
-// Standalone binaries do not appear to have this problem. The reasons are a
-// little mysterious, and more information can be found in #11731.
-//
-// For now we provide a way to tell libstd about the crate map manually that's
-// checked before the normal weak symbol/dlopen paths. In theory this is useful
-// on other platforms where our dlopen/weak linkage strategy mysteriously fails
-// but the crate map can be specified manually.
-static mut MANUALLY_PROVIDED_CRATE_MAP: *CrateMap<'static> =
-                                                    0 as *CrateMap<'static>;
-#[no_mangle]
-#[cfg(not(test))]
-pub extern fn rust_set_crate_map(map: *CrateMap<'static>) {
-    unsafe { MANUALLY_PROVIDED_CRATE_MAP = map; }
-}
-
-fn manual_crate_map() -> Option<&'static CrateMap<'static>> {
-    unsafe {
-        if MANUALLY_PROVIDED_CRATE_MAP.is_null() {
-            None
-        } else {
-            Some(cast::transmute(MANUALLY_PROVIDED_CRATE_MAP))
-        }
-    }
-}
-
 #[cfg(not(windows))]
 pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
     extern {
         #[crate_map]
         static CRATE_MAP: CrateMap<'static>;
     }
 
-    manual_crate_map().or_else(|| {
-        let ptr: (*CrateMap) = &'static CRATE_MAP;
-        if ptr.is_null() {
-            None
-        } else {
-            Some(&'static CRATE_MAP)
-        }
-    })
+    let ptr: (*CrateMap) = &'static CRATE_MAP;
+    if ptr.is_null() {
+        return None;
+    } else {
+        return Some(&'static CRATE_MAP);
+    }
 }
 
 #[cfg(windows)]
 pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
+    use cast::transmute;
     use c_str::ToCStr;
     use unstable::dynamic_lib::dl;
 
-    match manual_crate_map() {
-        Some(cm) => return Some(cm),
-        None => {}
-    }
-
     let sym = unsafe {
         let module = dl::open_internal();
         let rust_crate_map_toplevel = if cfg!(target_arch = "x86") {
@@ -109,7 +74,7 @@ pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
         return None;
     } else {
         unsafe {
-            return Some(cast::transmute(sym));
+            return Some(transmute(sym));
         }
     }
 }

branches/try/src/test/auxiliary/private_variant_1.rs

@@ -10,6 +10,6 @@
 
 mod super_sekrit {
     pub enum sooper_sekrit {
-        quux, priv baz
+        pub quux, priv baz
     }
 }

branches/try/src/test/bench/shootout-fannkuch-redux.rs

@@ -8,7 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// ignore-test reading from os::args()[1] - bogus!
+
+use std::from_str::FromStr;
 use std::os;
+use std::vec::MutableVector;
 use std::vec;
 
 fn max(a: i32, b: i32) -> i32 {
@@ -19,6 +23,7 @@ fn max(a: i32, b: i32) -> i32 {
     }
 }
 
+#[inline(never)]
 fn fannkuch_redux(n: i32) -> i32 {
     let mut perm = vec::from_elem(n as uint, 0i32);
     let mut perm1 = vec::from_fn(n as uint, |i| i as i32);
@@ -29,70 +34,74 @@ fn fannkuch_redux(n: i32) -> i32 {
 
     let mut r = n;
     loop {
-        while r != 1 {
-            count[r - 1] = r;
-            r -= 1;
-        }
-
-        for (perm_i, perm1_i) in perm.mut_iter().zip(perm1.iter()) {
-            *perm_i = *perm1_i;
-        }
-
-        let mut flips_count: i32 = 0;
-        let mut k: i32;
-        loop {
-            k = perm[0];
-            if k == 0 {
-                break;
+        unsafe {
+            while r != 1 {
+                count.unsafe_set((r-1) as uint, r);
+                r -= 1;
             }
 
-            let k2 = (k+1) >> 1;
-            for i in range(0i32, k2) {
-                perm.swap(i as uint, (k - i) as uint);
+            for (perm_i, perm1_i) in perm.mut_iter().zip(perm1.iter()) {
+                *perm_i = *perm1_i;
             }
-            flips_count += 1;
-        }
 
-        max_flips_count = max(max_flips_count, flips_count);
-        checksum += if perm_count % 2 == 0 {
-            flips_count
-        } else {
-            -flips_count
-        };
+            let mut flips_count: i32 = 0;
+            let mut k: i32;
+            loop {
+                k = *perm.unsafe_ref(0);
+                if k == 0 {
+                    break;
+                }
 
-        // Use incremental change to generate another permutation.
-        loop {
-            if r == n {
-                println!("{}", checksum);
-                return max_flips_count;
+                let k2 = (k+1) >> 1;
+                for i in range(0i32, k2) {
+                    let (perm_i, perm_k_i) = {
+                        (*perm.unsafe_ref(i as uint),
+                            *perm.unsafe_ref((k-i) as uint))
+                    };
+                    perm.unsafe_set(i as uint, perm_k_i);
+                    perm.unsafe_set((k-i) as uint, perm_i);
+                }
+                flips_count += 1;
             }
 
-            let perm0 = perm1[0];
-            let mut i: i32 = 0;
-            while i < r {
-                let j = i + 1;
-                perm1[i] = perm1[j];
-                i = j;
-            }
-            perm1[r] = perm0;
+            max_flips_count = max(max_flips_count, flips_count);
+            checksum += if perm_count % 2 == 0 {
+                flips_count
+            } else {
+                -flips_count
+            };
+
+            // Use incremental change to generate another permutation.
+            loop {
+                if r == n {
+                    println!("{}", checksum);
+                    return max_flips_count;
+                }
+
+                let perm0 = perm1[0];
+                let mut i: i32 = 0;
+                while i < r {
+                    let j = i + 1;
+                    let perm1_j = { *perm1.unsafe_ref(j as uint) };
+                    perm1.unsafe_set(i as uint, perm1_j);
+                    i = j;
+                }
+                perm1.unsafe_set(r as uint, perm0);
 
-            count[r] -= 1;
-            if count[r] > 0 {
-                break;
+                let count_r = { *count.unsafe_ref(r as uint) };
+                count.unsafe_set(r as uint, count_r - 1);
+                if *count.unsafe_ref(r as uint) > 0 {
+                    break;
+                }
+                r += 1;
             }
-            r += 1;
-        }
 
-        perm_count += 1;
+            perm_count += 1;
+        }
     }
 }
 
 fn main() {
-    let args = os::args();
-    let n = if args.len() > 1 {
-        from_str::<i32>(args[1]).unwrap()
-    } else {
-        2
-    };
+    let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
     println!("Pfannkuchen({}) = {}", n as int, fannkuch_redux(n) as int);
 }