---

yaml
---
r: 138239
b: refs/heads/auto
c: fa59bb0
h: refs/heads/master
i:
  138237: 2be1e16
  138235: f67a5d9
  138231: e5faa7e
  138223: 02d5722
  138207: 2f2bb60
  138175: c16b0f8
  138111: 62c3f14
  137983: f3dbc29
  137727: 9545a10
  137215: 4b4d2f9
v: v3

Author: bors

[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: a923b4ff6dcbf201441f820840e402a12d154e6d
+refs/heads/auto: fa59bb08699f2b9905adf20f103b6334e73f6b9f
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-                 url log regex graphviz core rbml rlibc alloc debug rustrt \
+                 url log regex graphviz core rbml rlibc alloc rustrt \
                  unicode
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
 	       rustc_llvm rustc_back
@@ -63,20 +63,19 @@ DEPS_libc := core
 DEPS_rlibc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
-DEPS_debug := std
 DEPS_rustrt := alloc core libc collections native:rustrt_native
 DEPS_std := core libc rand alloc collections rustrt sync unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_native := std
-DEPS_syntax := std term serialize log fmt_macros debug arena libc
+DEPS_syntax := std term serialize log fmt_macros arena libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
-              time log graphviz debug rustc_llvm rustc_back
+              time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
 DEPS_rustdoc := rustc native:hoedown serialize getopts \
-                test time debug
+                test time
 DEPS_flate := std native:miniz
 DEPS_arena := std
 DEPS_graphviz := std

branches/auto/src/compiletest/errors.rs

@@ -31,7 +31,7 @@ pub fn load_errors(re: &Regex, testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(line_num: uint, line: &str, re: &Regex) -> Option<ExpectedError> {
     re.captures(line).and_then(|caps| {
         let adjusts = caps.name("adjusts").len();
-        let kind = caps.name("kind").to_ascii().to_lower().into_string();
+        let kind = caps.name("kind").to_ascii().to_lowercase().into_string();
         let msg = caps.name("msg").trim().to_string();
 
         debug!("line={} kind={} msg={}", line_num, kind, msg);

branches/auto/src/doc/guide.md

@@ -1496,87 +1496,102 @@ low-level details matter, they really matter. Just remember that `String`s
 allocate memory and control their data, while `&str`s are a reference to
 another string, and you'll be all set.
 
-# Vectors
+# Arrays, Vectors, and Slices
 
-Like many programming languages, Rust has a list type for when you want a list
-of things. But similar to strings, Rust has different types to represent this
-idea: `Vec<T>` (a 'vector'), `[T, .. N]` (an 'array'), and `&[T]` (a 'slice').
-Whew!
+Like many programming languages, Rust has list types to represent a sequence of
+things. The most basic is the **array**, a fixed-size list of elements of the
+same type. By default, arrays are immutable.
 
-Vectors are similar to `String`s: they have a dynamic length, and they
-allocate enough memory to fit. You can create a vector with the `vec!` macro:
+```{rust}
+let a = [1i, 2i, 3i];
+let mut m = [1i, 2i, 3i];
+```
+
+You can create an array with a given number of elements, all initialized to the
+same value, with `[val, ..N]` syntax. The compiler ensures that arrays are
+always initialized.
 
 ```{rust}
-let nums = vec![1i, 2i, 3i];
+let a = [0i, ..20];  // Shorthand for array of 20 elements all initialized to 0
 ```
 
-Notice that unlike the `println!` macro we've used in the past, we use square
-brackets (`[]`) with `vec!`. Rust allows you to use either in either situation,
-this is just convention.
+Arrays have type `[T,..N]`. We'll talk about this `T` notation later, when we
+cover generics.
 
-You can create an array with just square brackets:
+You can get the number of elements in an array `a` with `a.len()`, and use
+`a.iter()` to iterate over them with a for loop. This code will print each
+number in order:
 
 ```{rust}
-let nums = [1i, 2i, 3i];
-let nums = [1i, ..20]; // Shorthand for an array of 20 elements all initialized to 1
+let a = [1i, 2, 3];     // Only the first item needs a type suffix
+
+println!("a has {} elements", a.len());
+for e in a.iter() {
+    println!("{}", e);
+}
 ```
 
-So what's the difference? An array has a fixed size, so you can't add or
-subtract elements:
+You can access a particular element of an array with **subscript notation**:
 
-```{rust,ignore}
-let mut nums = vec![1i, 2i, 3i];
-nums.push(4i); // works
+```{rust}
+let names = ["Graydon", "Brian", "Niko"];
 
-let mut nums = [1i, 2i, 3i];
-nums.push(4i); //  error: type `[int, .. 3]` does not implement any method
-               // in scope named `push`
+println!("The second name is: {}", names[1]);
 ```
 
-The `push()` method lets you append a value to the end of the vector. But
-since arrays have fixed sizes, adding an element doesn't make any sense.
-You can see how it has the exact type in the error message: `[int, .. 3]`.
-An array of `int`s, with length 3.
+Subscripts start at zero, like in most programming languages, so the first name
+is `names[0]` and the second name is `names[1]`. The above example prints
+`The second name is: Brian`. If you try to use a subscript that is not in the
+array, you will get an error: array access is bounds-checked at run-time. Such
+errant access is the source of many bugs in other systems programming
+languages.
 
-Similar to `&str`, a slice is a reference to another array. We can get a
-slice from a vector by using the `as_slice()` method:
+A **vector** is a dynamic or "growable" array, implemented as the standard
+library type [`Vec<T>`](std/vec/) (we'll talk about what the `<T>` means
+later). Vectors are to arrays what `String` is to `&str`. You can create them
+with the `vec!` macro:
 
 ```{rust}
-let vec = vec![1i, 2i, 3i];
-let slice = vec.as_slice();
+let v = vec![1i, 2, 3];
 ```
 
-All three types implement an `iter()` method, which returns an iterator. We'll
-talk more about the details of iterators later, but for now, the `iter()` method
-allows you to write a `for` loop that prints out the contents of a vector, array,
-or slice:
+(Notice that unlike the `println!` macro we've used in the past, we use square
+brackets `[]` with `vec!`. Rust allows you to use either in either situation,
+this is just convention.)
 
-```{rust}
-let vec = vec![1i, 2i, 3i];
+You can get the length of, iterate over, and subscript vectors just like
+arrays. In addition, (mutable) vectors can grow automatically:
 
-for i in vec.iter() {
-    println!("{}", i);
-}
+```{rust}
+let mut nums = vec![1i, 2, 3];
+nums.push(4);
+println!("The length of nums is now {}", nums.len());   // Prints 4
 ```
 
-This code will print each number in order, on its own line.
+Vectors have many more useful methods.
 
-You can access a particular element of a vector, array, or slice by using
-**subscript notation**:
+A **slice** is a reference to (or "view" into) an array. They are useful for
+allowing safe, efficient access to a portion of an array without copying. For
+example, you might want to reference just one line of a file read into memory.
+By nature, a slice is not created directly, but from an existing variable.
+Slices have a length, can be mutable or not, and in many ways behave like
+arrays:
 
 ```{rust}
-let names = ["Graydon", "Brian", "Niko"];
+let a = [0i, 1, 2, 3, 4];
+let middle = a.slice(1, 4);     // A slice of a: just the elements [1,2,3]
 
-println!("The second name is: {}", names[1]);
+for e in middle.iter() {
+    println!("{}", e);          // Prints 1, 2, 3
+}
 ```
 
-These subscripts start at zero, like in most programming languages, so the
-first name is `names[0]` and the second name is `names[1]`. The above example
-prints `The second name is: Brian`.
+You can also take a slice of a vector, `String`, or `&str`, because they are
+backed by arrays. Slices have type `&[T]`, which we'll talk about when we cover
+generics.
 
-There's a whole lot more to vectors, but that's enough to get started. We have
-now learned all of the most basic Rust concepts. We're ready to start building
-our guessing game, but we need to know how to do one last thing first: get
+We have now learned all of the most basic Rust concepts. We're ready to start
+building our guessing game, we just need to know one last thing: how to get
 input from the keyboard. You can't have a guessing game without the ability to
 guess!
 

branches/auto/src/doc/reference.md

@@ -1177,7 +1177,7 @@ This is a list of behaviour not considered *unsafe* in Rust terms, but that may
 be undesired.
 
 * Deadlocks
-* Reading data from private fields (`std::repr`, `format!("{:?}", x)`)
+* Reading data from private fields (`std::repr`)
 * Leaks due to reference count cycles, even in the global heap
 * Exiting without calling destructors
 * Sending signals
@@ -2279,8 +2279,6 @@ These types help drive the compiler's analysis
   : The lifetime parameter should be considered invariant
 * `malloc`
   : Allocate memory on the managed heap.
-* `opaque`
-  : ___Needs filling in___
 * `owned_box`
   : ___Needs filling in___
 * `stack_exhausted`
@@ -2295,8 +2293,6 @@ These types help drive the compiler's analysis
   : The type parameter should be considered invariant
 * `ty_desc`
   : ___Needs filling in___
-* `ty_visitor`
-  : ___Needs filling in___
 
 > **Note:** This list is likely to become out of date. We should auto-generate
 > it from `librustc/middle/lang_items.rs`.

branches/auto/src/liballoc/arc.rs

@@ -317,8 +317,6 @@ mod tests {
 
         assert_eq!((*arc_v)[2], 3);
         assert_eq!((*arc_v)[4], 5);
-
-        info!("{:?}", arc_v);
     }
 
     #[test]

branches/auto/src/liballoc/lib.rs

@@ -77,7 +77,6 @@ extern crate libc;
 
 // Allow testing this library
 
-#[cfg(test)] extern crate debug;
 #[cfg(test)] extern crate native;
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;

branches/auto/src/libcollections/hash/sip.rs

@@ -402,7 +402,7 @@ mod tests {
             debug!("siphash test {}: {}", t, buf);
             let vec = u8to64_le!(vecs[t], 0);
             let out = hash_with_keys(k0, k1, &Bytes(buf.as_slice()));
-            debug!("got {:?}, expected {:?}", out, vec);
+            debug!("got {}, expected {}", out, vec);
             assert_eq!(vec, out);
 
             state_full.reset();
@@ -412,9 +412,6 @@ mod tests {
             let v = to_hex_str(&vecs[t]);
             debug!("{}: ({}) => inc={} full={}", t, v, i, f);
 
-            debug!("full state {:?}", state_full);
-            debug!("inc  state {:?}", state_inc);
-
             assert_eq!(f, i);
             assert_eq!(f, v);
 

branches/auto/src/libcollections/lib.rs

@@ -33,7 +33,6 @@ extern crate alloc;
 
 #[cfg(test)] extern crate native;
 #[cfg(test)] extern crate test;
-#[cfg(test)] extern crate debug;
 
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;

branches/auto/src/libcollections/ringbuf.rs

@@ -551,21 +551,21 @@ mod tests {
         assert_eq!(d.len(), 3u);
         d.push(137);
         assert_eq!(d.len(), 4u);
-        debug!("{:?}", d.front());
+        debug!("{}", d.front());
         assert_eq!(*d.front().unwrap(), 42);
-        debug!("{:?}", d.back());
+        debug!("{}", d.back());
         assert_eq!(*d.back().unwrap(), 137);
         let mut i = d.pop_front();
-        debug!("{:?}", i);
+        debug!("{}", i);
         assert_eq!(i, Some(42));
         i = d.pop();
-        debug!("{:?}", i);
+        debug!("{}", i);
         assert_eq!(i, Some(137));
         i = d.pop();
-        debug!("{:?}", i);
+        debug!("{}", i);
         assert_eq!(i, Some(137));
         i = d.pop();
-        debug!("{:?}", i);
+        debug!("{}", i);
         assert_eq!(i, Some(17));
         assert_eq!(d.len(), 0u);
         d.push(3);
@@ -576,10 +576,10 @@ mod tests {
         assert_eq!(d.len(), 3u);
         d.push_front(1);
         assert_eq!(d.len(), 4u);
-        debug!("{:?}", d.get(0));
-        debug!("{:?}", d.get(1));
-        debug!("{:?}", d.get(2));
-        debug!("{:?}", d.get(3));
+        debug!("{}", d.get(0));
+        debug!("{}", d.get(1));
+        debug!("{}", d.get(2));
+        debug!("{}", d.get(3));
         assert_eq!(*d.get(0), 1);
         assert_eq!(*d.get(1), 2);
         assert_eq!(*d.get(2), 3);

branches/auto/src/libcollections/slice.rs

@@ -101,6 +101,7 @@ use vec::Vec;
 
 pub use core::slice::{Chunks, AsSlice, ImmutableSlice, ImmutablePartialEqSlice};
 pub use core::slice::{ImmutableOrdSlice, MutableSlice, Items, MutItems};
+pub use core::slice::{ImmutableIntSlice, MutableIntSlice};
 pub use core::slice::{MutSplits, MutChunks, Splits};
 pub use core::slice::{bytes, mut_ref_slice, ref_slice, MutableCloneableSlice};
 pub use core::slice::{Found, NotFound};

branches/auto/src/libcollections/vec.rs

@@ -453,13 +453,13 @@ impl<T> Index<uint,T> for Vec<T> {
     }
 }
 
-// FIXME(#12825) Indexing will always try IndexMut first and that causes issues.
-/*impl<T> IndexMut<uint,T> for Vec<T> {
+#[cfg(not(stage0))]
+impl<T> IndexMut<uint,T> for Vec<T> {
     #[inline]
     fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T {
         self.get_mut(*index)
     }
-}*/
+}
 
 impl<T> ops::Slice<uint, [T]> for Vec<T> {
     #[inline]
@@ -2154,7 +2154,6 @@ impl<T> Vec<T> {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     extern crate test;

branches/auto/src/libcore/intrinsics.rs

@@ -58,17 +58,21 @@ pub struct TyDesc {
     pub drop_glue: GlueFn,
 
     // Called by reflection visitor to visit a value of type `T`
+    #[cfg(stage0)]
     pub visit_glue: GlueFn,
 
     // Name corresponding to the type
     pub name: &'static str,
 }
 
+#[cfg(stage0)]
 #[lang="opaque"]
 pub enum Opaque { }
 
+#[cfg(stage0)]
 pub type Disr = u64;
 
+#[cfg(stage0)]
 #[lang="ty_visitor"]
 pub trait TyVisitor {
     fn visit_bot(&mut self) -> bool;
@@ -327,8 +331,6 @@ extern "rust-intrinsic" {
     /// Returns `true` if a type is managed (will be allocated on the local heap)
     pub fn owns_managed<T>() -> bool;
 
-    pub fn visit_tydesc(td: *const TyDesc, tv: &mut TyVisitor);
-
     /// Calculates the offset from a pointer. The offset *must* be in-bounds of
     /// the object, or one-byte-past-the-end. An arithmetic overflow is also
     /// undefined behaviour.