---

yaml
---
r: 153296
b: refs/heads/try2
c: b9e35a1
h: refs/heads/master
v: v3

Author: huonw

[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: 898701cb35833b2ecea8bc7f3902a35b7eccc219
+refs/heads/try2: b9e35a164416272a3aa3778c2ce9669dcc15c556
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/target.mk

@@ -68,6 +68,15 @@ $(foreach host,$(CFG_HOST),						    \
 # $(4) is the crate name
 define RUST_TARGET_STAGE_N
 
+# NOTE: after a stage0 snap this should be just EXTRA_FILENAME, not with a stage
+# or target bound
+EXTRA_FILENAME_$(1)_$(2) = -C extra-filename=-$$(CFG_FILENAME_EXTRA)
+ifeq ($(1),0)
+ifeq ($$(CFG_BUILD),$(2))
+EXTRA_FILENAME_$(1)_$(2) =
+endif
+endif
+
 $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): CFG_COMPILER_HOST_TRIPLE = $(2)
 $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4):				    \
 		$$(CRATEFILE_$(4))				    \
@@ -86,7 +95,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4):				    \
 		-L "$$(dir $$(LLVM_STDCPP_LOCATION_$(2)))" \
 		$$(RUSTFLAGS_$(4)) \
 		--out-dir $$(@D) \
-		-C extra-filename=-$$(CFG_FILENAME_EXTRA) \
+		$$(EXTRA_FILENAME_$(1)_$(2)) \
 		$$<
 	@touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES,\

branches/try2/src/doc/guide.md

@@ -273,11 +273,16 @@ is still a work in progress. However, it is already good enough to use for many
 Rust projects, and so it is assumed that Rust projects will use Cargo from the
 beginning.
 
-Cargo manages three things: building your code, downloading the dependencies
-your code needs, and building the dependencies your code needs.  At first, your
-program doesn't have any dependencies, so we'll only be using the first part of
-its functionality. Eventually, we'll add more. Since we started off by using
-Cargo, it'll be easy to add later.
+Programmers love car analogies, so I've got a good one for you to think about
+the relationship between `cargo` and `rustc`: `rustc` is like a car, and
+`cargo` is like a robotic driver. You can drive your car yourself, of course,
+but isn't it just easier to let a computer drive it for you?
+
+Anyway, Cargo manages three things: building your code, downloading the
+dependencies your code needs, and building the dependencies your code needs.
+At first, your program doesn't have any dependencies, so we'll only be using
+the first part of its functionality. Eventually, we'll add more. Since we
+started off by using Cargo, it'll be easy to add later.
 
 Let's convert Hello World to Cargo. The first thing we need to do to begin using Cargo
 is to install Cargo. To do this, we need to build it from source. There are no binaries

branches/try2/src/etc/install.sh

@@ -285,19 +285,6 @@ then
     CFG_LIBDIR_RELATIVE=bin
 fi
 
-if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
-then
-    CFG_LD_PATH_VAR=PATH
-    CFG_OLD_LD_PATH_VAR=$PATH
-elif [ "$CFG_OSTYPE" = "Darwin" ]
-then
-    CFG_LD_PATH_VAR=DYLD_LIBRARY_PATH
-    CFG_OLD_LD_PATH_VAR=$DYLD_LIBRARY_PATH
-else
-    CFG_LD_PATH_VAR=LD_LIBRARY_PATH
-    CFG_OLD_LD_PATH_VAR=$LD_LIBRARY_PATH
-fi
-
 flag uninstall "only uninstall from the installation prefix"
 opt verify 1 "verify that the installed binaries run correctly"
 valopt prefix "/usr/local" "set installation prefix"
@@ -325,13 +312,11 @@ then
     if [ -z "${CFG_UNINSTALL}" ]
     then
         msg "verifying platform can run binaries"
-        export $CFG_LD_PATH_VAR="${CFG_SRC_DIR}/lib":$CFG_OLD_LD_PATH_VAR
         "${CFG_SRC_DIR}/bin/rustc" --version > /dev/null
         if [ $? -ne 0 ]
         then
             err "can't execute rustc binary on this platform"
         fi
-        export $CFG_LD_PATH_VAR=$CFG_OLD_LD_PATH_VAR
     fi
 fi
 
@@ -467,31 +452,17 @@ while read p; do
 done < "${CFG_SRC_DIR}/${CFG_LIBDIR_RELATIVE}/rustlib/manifest.in"
 
 # Sanity check: can we run the installed binaries?
-#
-# As with the verification above, make sure the right LD_LIBRARY_PATH-equivalent
-# is in place. Try first without this variable, and if that fails try again with
-# the variable. If the second time tries, print a hopefully helpful message to
-# add something to the appropriate environment variable.
 if [ -z "${CFG_DISABLE_VERIFY}" ]
 then
     msg "verifying installed binaries are executable"
-    "${CFG_PREFIX}/bin/rustc" --version 2> /dev/null 1> /dev/null
+    "${CFG_PREFIX}/bin/rustc" --version > /dev/null
     if [ $? -ne 0 ]
     then
-        export $CFG_LD_PATH_VAR="${CFG_PREFIX}/lib":$CFG_OLD_LD_PATH_VAR
-        "${CFG_PREFIX}/bin/rustc" --version > /dev/null
-        if [ $? -ne 0 ]
-        then
-            ERR="can't execute installed rustc binary. "
-            ERR="${ERR}installation may be broken. "
-            ERR="${ERR}if this is expected then rerun install.sh with \`--disable-verify\` "
-            ERR="${ERR}or \`make install\` with \`--disable-verify-install\`"
-            err "${ERR}"
-        else
-            echo
-            echo "    please ensure '${CFG_PREFIX}/lib' is added to ${CFG_LD_PATH_VAR}"
-            echo
-        fi
+        ERR="can't execute installed rustc binary. "
+        ERR="${ERR}installation may be broken. "
+        ERR="${ERR}if this is expected then rerun install.sh with \`--disable-verify\` "
+        ERR="${ERR}or \`make install\` with \`--disable-verify-install\`"
+        err "${ERR}"
     fi
 fi
 

branches/try2/src/liballoc/lib.rs

@@ -60,6 +60,7 @@
 //! by libc malloc/free.  The `libc_heap` module is defined to be wired up to
 //! the system malloc/free.
 
+#![crate_id = "alloc#0.11.0"] // NOTE: remove after a stage0 snap
 #![crate_name = "alloc"]
 #![experimental]
 #![license = "MIT/ASL2"]
@@ -70,6 +71,7 @@
 
 #![no_std]
 #![feature(lang_items, phase, unsafe_destructor)]
+#![allow(unused_attribute)] // NOTE: remove after stage0
 
 #[phase(plugin, link)]
 extern crate core;

branches/try2/src/libarena/lib.rs

@@ -19,6 +19,7 @@
 //! arena but can only hold objects of a single type, and Arena, which is a
 //! more complex, slower Arena which can hold objects of any type.
 
+#![crate_id = "arena#0.11.0"]
 #![crate_name = "arena"]
 #![experimental]
 #![crate_type = "rlib"]
@@ -30,6 +31,7 @@
 
 #![feature(unsafe_destructor)]
 #![allow(missing_doc)]
+#![allow(unused_attribute)] // NOTE: remove after stage0
 
 use std::cell::{Cell, RefCell};
 use std::cmp;

branches/try2/src/libcollections/bitv.rs

@@ -16,16 +16,20 @@ use core::cmp;
 use core::default::Default;
 use core::fmt;
 use core::iter::Take;
-use core::ops::Index;
 use core::slice;
 use core::uint;
 use std::hash;
 
 use {Collection, Mutable, Set, MutableSet};
 use vec::Vec;
 
+#[cfg(not(stage0))]
+use core::ops::Index;
 
+#[cfg(not(stage0))]
 static TRUE: bool = true;
+
+#[cfg(not(stage0))]
 static FALSE: bool = false;
 
 #[deriving(Clone)]
@@ -76,6 +80,7 @@ pub struct Bitv {
     nbits: uint
 }
 
+#[cfg(not(stage0))]
 impl Index<uint,bool> for Bitv {
     #[inline]
     fn index<'a>(&'a self, i: &uint) -> &'a bool {
@@ -1421,14 +1426,18 @@ mod tests {
     fn test_small_clear() {
         let mut b = Bitv::with_capacity(14, true);
         b.clear();
-        assert!(b.none());
+        BitvSet::from_bitv(b).iter().advance(|i| {
+            fail!("found 1 at {:?}", i)
+        });
     }
 
     #[test]
     fn test_big_clear() {
         let mut b = Bitv::with_capacity(140, true);
         b.clear();
-        assert!(b.none());
+        BitvSet::from_bitv(b).iter().advance(|i| {
+            fail!("found 1 at {:?}", i)
+        });
     }
 
     #[test]
@@ -1485,9 +1494,14 @@ mod tests {
         assert!(b.insert(5));
         assert!(b.insert(3));
 
+        let mut i = 0;
         let expected = [3, 5, 11, 77];
-        let actual = a.intersection(&b).collect::<Vec<uint>>();
-        assert_eq!(actual.as_slice(), expected.as_slice());
+        a.intersection(&b).advance(|x| {
+            assert_eq!(x, expected[i]);
+            i += 1;
+            true
+        });
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1504,9 +1518,14 @@ mod tests {
         assert!(b.insert(3));
         assert!(b.insert(200));
 
+        let mut i = 0;
         let expected = [1, 5, 500];
-        let actual = a.difference(&b).collect::<Vec<uint>>();
-        assert_eq!(actual.as_slice(), expected.as_slice());
+        a.difference(&b).advance(|x| {
+            assert_eq!(x, expected[i]);
+            i += 1;
+            true
+        });
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1525,9 +1544,14 @@ mod tests {
         assert!(b.insert(14));
         assert!(b.insert(220));
 
+        let mut i = 0;
         let expected = [1, 5, 11, 14, 220];
-        let actual = a.symmetric_difference(&b).collect::<Vec<uint>>();
-        assert_eq!(actual.as_slice(), expected.as_slice());
+        a.symmetric_difference(&b).advance(|x| {
+            assert_eq!(x, expected[i]);
+            i += 1;
+            true
+        });
+        assert_eq!(i, expected.len());
     }
 
     #[test]
@@ -1549,9 +1573,14 @@ mod tests {
         assert!(b.insert(13));
         assert!(b.insert(19));
 
+        let mut i = 0;
         let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160];
-        let actual = a.union(&b).collect::<Vec<uint>>();
-        assert_eq!(actual.as_slice(), expected.as_slice());
+        a.union(&b).advance(|x| {
+            assert_eq!(x, expected[i]);
+            i += 1;
+            true
+        });
+        assert_eq!(i, expected.len());
     }
 
     #[test]

branches/try2/src/libcollections/lib.rs

@@ -12,6 +12,7 @@
  * Collection types.
  */
 
+#![crate_id = "collections#0.11.0"] // NOTE: remove after stage0
 #![crate_name = "collections"]
 #![experimental]
 #![crate_type = "rlib"]
@@ -24,6 +25,7 @@
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
 #![feature(unsafe_destructor)]
 #![no_std]
+#![allow(unused_attribute)] // NOTE: remove after stage0
 
 #[phase(plugin, link)] extern crate core;
 extern crate unicode;

branches/try2/src/libcollections/treemap.rs

@@ -1770,7 +1770,7 @@ mod test_set {
     #[test]
     fn test_intersection() {
         fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
-            check(a, b, expected, |x, y, f| x.intersection(y).all(f))
+            check(a, b, expected, |x, y, f| x.intersection(y).advance(f))
         }
 
         check_intersection([], [], []);
@@ -1786,7 +1786,7 @@ mod test_set {
     #[test]
     fn test_difference() {
         fn check_difference(a: &[int], b: &[int], expected: &[int]) {
-            check(a, b, expected, |x, y, f| x.difference(y).all(f))
+            check(a, b, expected, |x, y, f| x.difference(y).advance(f))
         }
 
         check_difference([], [], []);
@@ -1804,7 +1804,7 @@ mod test_set {
     fn test_symmetric_difference() {
         fn check_symmetric_difference(a: &[int], b: &[int],
                                       expected: &[int]) {
-            check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
+            check(a, b, expected, |x, y, f| x.symmetric_difference(y).advance(f))
         }
 
         check_symmetric_difference([], [], []);
@@ -1819,7 +1819,7 @@ mod test_set {
     fn test_union() {
         fn check_union(a: &[int], b: &[int],
                                       expected: &[int]) {
-            check(a, b, expected, |x, y, f| x.union(y).all(f))
+            check(a, b, expected, |x, y, f| x.union(y).advance(f))
         }
 
         check_union([], [], []);

branches/try2/src/libcore/iter.rs

@@ -435,10 +435,9 @@ pub trait Iterator<A> {
     ///
     /// # Example
     ///
-    /// ```rust,ignore
+    /// ```rust
     /// range(0u, 5).advance(|x| {print!("{} ", x); true});
     /// ```
-    #[deprecated = "use the `all` method instead"]
     #[inline]
     fn advance(&mut self, f: |A| -> bool) -> bool {
         loop {

branches/try2/src/libcore/lib.rs

@@ -47,6 +47,7 @@
 // Since libcore defines many fundamental lang items, all tests live in a
 // separate crate, libcoretest, to avoid bizarre issues.
 
+#![crate_id = "core#0.11.0"]
 #![crate_name = "core"]
 #![experimental]
 #![license = "MIT/ASL2"]
@@ -60,6 +61,7 @@
 #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
 #![feature(simd, unsafe_destructor)]
 #![deny(missing_doc)]
+#![allow(unused_attribute)] // NOTE: remove after stage0
 
 mod macros;
 

branches/try2/src/libcore/ops.rs

@@ -636,6 +636,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * ```
  */
 #[lang="index"]
+#[cfg(not(stage0))]
 pub trait Index<Index,Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index<'a>(&'a self, index: &Index) -> &'a Result;
@@ -667,6 +668,7 @@ pub trait Index<Index,Result> {
  * ```
  */
 #[lang="index_mut"]
+#[cfg(not(stage0))]
 pub trait IndexMut<Index,Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Result;

branches/try2/src/libcore/prelude.rs

@@ -34,6 +34,7 @@ pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Drop, Deref, DerefMut};
 pub use ops::{Shl, Shr};
+#[cfg(not(stage0))]
 pub use ops::{Index, IndexMut};
 pub use option::{Option, Some, None};
 pub use result::{Result, Ok, Err};

branches/try2/src/libdebug/lib.rs

@@ -16,6 +16,7 @@
 //! Additionally, it is not guaranteed that functionality such as reflection
 //! will persist into the future.
 
+#![crate_id = "debug#0.11.0"] // NOTE: remove after stage0
 #![crate_name = "debug"]
 #![experimental]
 #![license = "MIT/ASL2"]
@@ -27,6 +28,7 @@
 #![experimental]
 #![feature(managed_boxes, macro_rules)]
 #![allow(experimental)]
+#![allow(unused_attribute)] // NOTE: remove after stage0
 
 pub mod fmt;
 pub mod reflect;