---

yaml
---
r: 145089
b: refs/heads/try2
c: 1f961c7
h: refs/heads/master
i:
  145087: 6ad15fc
v: v3

Author: thestinger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ccadbd3b7c936dacab69856cc3963aad477c7f06
+refs/heads/try2: 1f961c74c4995b628ddb6c405295d78f9e79a849
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustpkg/tests.rs

@@ -1111,55 +1111,6 @@ 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/try2/src/librustpkg/util.rs

@@ -268,8 +268,10 @@ 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())] +
-            ~[attr::mk_name_value_item_str(@"package_id",
-                                           pkg_id.path.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 { ~[] };
 
         debug!("link options: %?", link_options);
         crate = @ast::Crate {

branches/try2/src/libstd/iter.rs

@@ -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.state < self.stop {
+        if (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,
@@ -1891,22 +1891,14 @@ 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 {
-            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
-                }
+        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
             }
+            Some(result)
         } else {
             None
         }
@@ -2726,13 +2718,15 @@ mod tests {
     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]);
     }
 
     #[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]);
     }