---

yaml
---
r: 123490
b: refs/heads/auto
c: b9e35a1
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -13,7 +13,7 @@ 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: 898701cb35833b2ecea8bc7f3902a35b7eccc219
+refs/heads/auto: b9e35a164416272a3aa3778c2ce9669dcc15c556
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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/auto/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;