---

yaml
---
r: 80799
b: refs/heads/try
c: a7e49d6
h: refs/heads/master
i:
  80797: 1afdabc
  80795: fa9b277
  80791: fb3d9d0
  80783: 2b5e242
  80767: 3493960
v: v3

Author: catamorphism

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 6e3d5c62e79026920d09833889ea837b19b0a9d0
+refs/heads/try: a7e49d6e83f61989b2456c213daeb7461d9ee606
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libextra/crypto/md5.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::iter::range_step;
+use std::uint;
 
 use cryptoutil::{write_u32_le, read_u32v_le, FixedBuffer, FixedBuffer64, StandardPadding};
 use digest::Digest;
@@ -86,42 +86,46 @@ impl Md5State {
         read_u32v_le(data, input);
 
         // round 1
-        for i in range_step(0u, 16, 4) {
+        do uint::range_step(0, 16, 4) |i| {
             a = op_f(a, b, c, d, data[i] + C1[i], 7);
             d = op_f(d, a, b, c, data[i + 1] + C1[i + 1], 12);
             c = op_f(c, d, a, b, data[i + 2] + C1[i + 2], 17);
             b = op_f(b, c, d, a, data[i + 3] + C1[i + 3], 22);
-        }
+            true
+        };
 
         // round 2
         let mut t = 1;
-        for i in range_step(0u, 16, 4) {
+        do uint::range_step(0, 16, 4) |i| {
             a = op_g(a, b, c, d, data[t & 0x0f] + C2[i], 5);
             d = op_g(d, a, b, c, data[(t + 5) & 0x0f] + C2[i + 1], 9);
             c = op_g(c, d, a, b, data[(t + 10) & 0x0f] + C2[i + 2], 14);
             b = op_g(b, c, d, a, data[(t + 15) & 0x0f] + C2[i + 3], 20);
             t += 20;
-        }
+            true
+        };
 
         // round 3
         t = 5;
-        for i in range_step(0u, 16, 4) {
+        do uint::range_step(0, 16, 4) |i| {
             a = op_h(a, b, c, d, data[t & 0x0f] + C3[i], 4);
             d = op_h(d, a, b, c, data[(t + 3) & 0x0f] + C3[i + 1], 11);
             c = op_h(c, d, a, b, data[(t + 6) & 0x0f] + C3[i + 2], 16);
             b = op_h(b, c, d, a, data[(t + 9) & 0x0f] + C3[i + 3], 23);
             t += 12;
-        }
+            true
+        };
 
         // round 4
         t = 0;
-        for i in range_step(0u, 16, 4) {
+        do uint::range_step(0, 16, 4) |i| {
             a = op_i(a, b, c, d, data[t & 0x0f] + C4[i], 6);
             d = op_i(d, a, b, c, data[(t + 7) & 0x0f] + C4[i + 1], 10);
             c = op_i(c, d, a, b, data[(t + 14) & 0x0f] + C4[i + 2], 15);
             b = op_i(b, c, d, a, data[(t + 21) & 0x0f] + C4[i + 3], 21);
             t += 28;
-        }
+            true
+        };
 
         self.s0 += a;
         self.s1 += b;

branches/try/src/libextra/crypto/sha2.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::iter::range_step;
+use std::uint;
 
 use cryptoutil::{write_u64_be, write_u32_be, read_u64v_be, read_u32v_be, add_bytes_to_bits,
     add_bytes_to_bits_tuple, FixedBuffer, FixedBuffer128, FixedBuffer64, StandardPadding};
@@ -111,7 +111,7 @@ impl Engine512State {
 
         // Putting the message schedule inside the same loop as the round calculations allows for
         // the compiler to generate better code.
-        for t in range_step(0u, 64, 8) {
+        do uint::range_step(0, 64, 8) |t| {
             schedule_round!(t + 16);
             schedule_round!(t + 17);
             schedule_round!(t + 18);
@@ -129,9 +129,10 @@ impl Engine512State {
             sha2_round!(d, e, f, g, h, a, b, c, K64, t + 5);
             sha2_round!(c, d, e, f, g, h, a, b, K64, t + 6);
             sha2_round!(b, c, d, e, f, g, h, a, K64, t + 7);
-        }
+            true
+        };
 
-        for t in range_step(64u, 80, 8) {
+        do uint::range_step(64, 80, 8) |t| {
             sha2_round!(a, b, c, d, e, f, g, h, K64, t);
             sha2_round!(h, a, b, c, d, e, f, g, K64, t + 1);
             sha2_round!(g, h, a, b, c, d, e, f, K64, t + 2);
@@ -140,7 +141,8 @@ impl Engine512State {
             sha2_round!(d, e, f, g, h, a, b, c, K64, t + 5);
             sha2_round!(c, d, e, f, g, h, a, b, K64, t + 6);
             sha2_round!(b, c, d, e, f, g, h, a, K64, t + 7);
-        }
+            true
+        };
 
         self.H0 += a;
         self.H1 += b;
@@ -525,7 +527,7 @@ impl Engine256State {
 
         // Putting the message schedule inside the same loop as the round calculations allows for
         // the compiler to generate better code.
-        for t in range_step(0u, 48, 8) {
+        do uint::range_step(0, 48, 8) |t| {
             schedule_round!(t + 16);
             schedule_round!(t + 17);
             schedule_round!(t + 18);
@@ -543,9 +545,10 @@ impl Engine256State {
             sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5);
             sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6);
             sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7);
-        }
+            true
+        };
 
-        for t in range_step(48u, 64, 8) {
+        do uint::range_step(48, 64, 8) |t| {
             sha2_round!(a, b, c, d, e, f, g, h, K32, t);
             sha2_round!(h, a, b, c, d, e, f, g, K32, t + 1);
             sha2_round!(g, h, a, b, c, d, e, f, K32, t + 2);
@@ -554,7 +557,8 @@ impl Engine256State {
             sha2_round!(d, e, f, g, h, a, b, c, K32, t + 5);
             sha2_round!(c, d, e, f, g, h, a, b, K32, t + 6);
             sha2_round!(b, c, d, e, f, g, h, a, K32, t + 7);
-        }
+            true
+        };
 
         self.H0 += a;
         self.H1 += b;

branches/try/src/librustpkg/tests.rs

@@ -1111,6 +1111,55 @@ fn test_extern_mod() {
     assert!(os::path_exists(&exec_file) && is_executable(&exec_file));
 }
 
+#[test]
+fn test_extern_mod_simpler() {
+    let dir = mkdtemp(&os::tmpdir(), "test_extern_mod_simpler").expect("test_extern_mod_simpler");
+    let main_file = dir.push("main.rs");
+    let lib_depend_dir = mkdtemp(&os::tmpdir(), "foo").expect("test_extern_mod_simpler");
+    let aux_dir = lib_depend_dir.push_many(["src", "rust-awesomeness"]);
+    assert!(os::mkdir_recursive(&aux_dir, U_RWX));
+    let aux_pkg_file = aux_dir.push("lib.rs");
+
+    writeFile(&aux_pkg_file, "pub mod bar { pub fn assert_true() {  assert!(true); } }\n");
+    assert!(os::path_exists(&aux_pkg_file));
+
+    writeFile(&main_file,
+              "extern mod test = \"rust-awesomeness\";\nuse test::bar;\
+               fn main() { bar::assert_true(); }\n");
+
+    command_line_test([~"install", ~"rust-awesomeness"], &lib_depend_dir);
+
+    let exec_file = dir.push("out");
+    // Be sure to extend the existing environment
+    let env = Some([(~"RUST_PATH", lib_depend_dir.to_str())] + os::env());
+    let rustpkg_exec = rustpkg_exec();
+    let rustc = rustpkg_exec.with_filename("rustc");
+    debug!("RUST_PATH=%s %s %s \n --sysroot %s -o %s",
+                     lib_depend_dir.to_str(),
+                     rustc.to_str(),
+                     main_file.to_str(),
+                     test_sysroot().to_str(),
+                     exec_file.to_str());
+
+    let mut prog = run::Process::new(rustc.to_str(), [main_file.to_str(),
+                                                      ~"--sysroot", test_sysroot().to_str(),
+                                               ~"-o", exec_file.to_str()],
+                                     run::ProcessOptions {
+        env: env,
+        dir: Some(&dir),
+        in_fd: None,
+        out_fd: None,
+        err_fd: None
+    });
+    let outp = prog.finish_with_output();
+    if outp.status != 0 {
+        fail!("output was %s, error was %s",
+              str::from_utf8(outp.output),
+              str::from_utf8(outp.error));
+    }
+    assert!(os::path_exists(&exec_file) && is_executable(&exec_file));
+}
+
 #[test]
 fn test_import_rustpkg() {
     let p_id = PkgId::new("foo");

branches/try/src/librustpkg/util.rs

@@ -268,10 +268,8 @@ pub fn compile_input(context: &BuildContext,
         let link_options =
             ~[attr::mk_name_value_item_str(@"name", name_to_use),
               attr::mk_name_value_item_str(@"vers", pkg_id.version.to_str().to_managed())] +
-                        if pkg_id.is_complex() {
-                        ~[attr::mk_name_value_item_str(@"package_id",
-                                                       pkg_id.path.to_str().to_managed())]
-                } else { ~[] };
+            ~[attr::mk_name_value_item_str(@"package_id",
+                                           pkg_id.path.to_str().to_managed())];
 
         debug!("link options: %?", link_options);
         crate = @ast::Crate {

branches/try/src/libstd/char.rs

@@ -12,7 +12,7 @@
 
 use cast::transmute;
 use option::{None, Option, Some};
-use iter::{Iterator, range_step};
+use i32;
 use str::StrSlice;
 use unicode::{derived_property, general_category, decompose};
 use to_str::ToStr;
@@ -286,14 +286,15 @@ pub fn escape_unicode(c: char, f: &fn(char)) {
         (c <= '\uffff') { f('u'); 4 }
         _               { f('U'); 8 }
     );
-    for offset in range_step::<i32>(4 * (pad - 1), -1, -4) {
+    do i32::range_step(4 * (pad - 1), -1, -4) |offset| {
         unsafe {
             match ((c as i32) >> offset) & 0xf {
                 i @ 0 .. 9 => { f(transmute('0' as i32 + i)); }
                 i => { f(transmute('a' as i32 + (i - 10))); }
             }
         }
-    }
+        true
+    };
 }
 
 ///

branches/try/src/libstd/iter.rs

@@ -1790,17 +1790,17 @@ pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> R
     RangeInclusive{range: range(start, stop), done: false}
 }
 
-impl<A: Add<A, A> + Eq + Ord + Clone> Iterator<A> for RangeInclusive<A> {
+impl<A: Add<A, A> + Ord + Clone> Iterator<A> for RangeInclusive<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         match self.range.next() {
             Some(x) => Some(x),
             None => {
-                if !self.done && self.range.state == self.range.stop {
+                if self.done {
+                    None
+                } else {
                     self.done = true;
                     Some(self.range.stop.clone())
-                } else {
-                    None
                 }
             }
         }
@@ -1829,11 +1829,11 @@ impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for RangeInclu
             let result = self.range.stop.clone();
             self.range.stop = self.range.stop - self.range.one;
             Some(result)
-        } else if !self.done && self.range.state == self.range.stop {
+        } else if self.done {
+            None
+        } else {
             self.done = true;
             Some(self.range.stop.clone())
-        } else {
-            None
         }
     }
 }
@@ -1857,7 +1857,7 @@ pub fn range_step<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A, step: A
 impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
-        if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
+        if (self.rev && self.state > self.stop) || self.state < self.stop {
             let result = self.state.clone();
             match self.state.checked_add(&self.step) {
                 Some(x) => self.state = x,
@@ -1891,14 +1891,22 @@ pub fn range_step_inclusive<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop:
 impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
-        if !self.done && ((self.rev && self.state >= self.stop) ||
-                          (!self.rev && self.state <= self.stop)) {
-            let result = self.state.clone();
-            match self.state.checked_add(&self.step) {
-                Some(x) => self.state = x,
-                None => self.done = true
+        if !self.done {
+            if (self.rev && self.state > self.stop) || self.state < self.stop {
+                let result = self.state.clone();
+                match self.state.checked_add(&self.step) {
+                    Some(x) => self.state = x,
+                    None => self.done = true
+                }
+                Some(result)
+            } else {
+                if self.state == self.stop {
+                    self.done = true;
+                    Some(self.state.clone())
+                } else {
+                    None
+                }
             }
-            Some(result)
         } else {
             None
         }
@@ -2712,30 +2720,20 @@ mod tests {
     fn test_range_inclusive() {
         assert_eq!(range_inclusive(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4, 5]);
         assert_eq!(range_inclusive(0i, 5).invert().collect::<~[int]>(), ~[5i, 4, 3, 2, 1, 0]);
-        assert_eq!(range_inclusive(200, -5).collect::<~[int]>(), ~[]);
-        assert_eq!(range_inclusive(200, -5).invert().collect::<~[int]>(), ~[]);
-        assert_eq!(range_inclusive(200, 200).collect::<~[int]>(), ~[200]);
-        assert_eq!(range_inclusive(200, 200).invert().collect::<~[int]>(), ~[200]);
     }
 
     #[test]
     fn test_range_step() {
         assert_eq!(range_step(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15]);
         assert_eq!(range_step(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5]);
-        assert_eq!(range_step(20i, 0, -6).collect::<~[int]>(), ~[20, 14, 8, 2]);
         assert_eq!(range_step(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]);
-        assert_eq!(range_step(200, -5, 1).collect::<~[int]>(), ~[]);
-        assert_eq!(range_step(200, 200, 1).collect::<~[int]>(), ~[]);
     }
 
     #[test]
     fn test_range_step_inclusive() {
         assert_eq!(range_step_inclusive(0i, 20, 5).collect::<~[int]>(), ~[0, 5, 10, 15, 20]);
         assert_eq!(range_step_inclusive(20i, 0, -5).collect::<~[int]>(), ~[20, 15, 10, 5, 0]);
-        assert_eq!(range_step_inclusive(20i, 0, -6).collect::<~[int]>(), ~[20, 14, 8, 2]);
         assert_eq!(range_step_inclusive(200u8, 255, 50).collect::<~[u8]>(), ~[200u8, 250]);
-        assert_eq!(range_step_inclusive(200, -5, 1).collect::<~[int]>(), ~[]);
-        assert_eq!(range_step_inclusive(200, 200, 1).collect::<~[int]>(), ~[200]);
     }
 
     #[test]