---

yaml
---
r: 138238
b: refs/heads/auto
c: a923b4f
h: refs/heads/master
v: v3

Author: IvanUkhov

[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: 0f8df80804b2c7e89acc3c8e046a1ac7a90124f6
+refs/heads/auto: a923b4ff6dcbf201441f820840e402a12d154e6d
 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 rustrt \
+                 url log regex graphviz core rbml rlibc alloc debug rustrt \
                  unicode
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros \
 	       rustc_llvm rustc_back
@@ -63,19 +63,20 @@ 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 arena libc
+DEPS_syntax := std term serialize log fmt_macros debug arena libc
 DEPS_rustc := syntax flate arena serialize getopts rbml \
-              time log graphviz rustc_llvm rustc_back
+              time log graphviz debug 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
+                test time debug
 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_lowercase().into_string();
+        let kind = caps.name("kind").to_ascii().to_lower().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,102 +1496,87 @@ 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.
 
-# Arrays, Vectors, and Slices
+# Vectors
 
-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.
+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!
 
-```{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.
+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 = [0i, ..20];  // Shorthand for array of 20 elements all initialized to 0
+let nums = vec![1i, 2i, 3i];
 ```
 
-Arrays have type `[T,..N]`. We'll talk about this `T` notation later, when we
-cover generics.
+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.
 
-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:
+You can create an array with just square brackets:
 
 ```{rust}
-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);
-}
+let nums = [1i, 2i, 3i];
+let nums = [1i, ..20]; // Shorthand for an array of 20 elements all initialized to 1
 ```
 
-You can access a particular element of an array with **subscript notation**:
+So what's the difference? An array has a fixed size, so you can't add or
+subtract elements:
 
-```{rust}
-let names = ["Graydon", "Brian", "Niko"];
+```{rust,ignore}
+let mut nums = vec![1i, 2i, 3i];
+nums.push(4i); // works
 
-println!("The second name is: {}", names[1]);
+let mut nums = [1i, 2i, 3i];
+nums.push(4i); //  error: type `[int, .. 3]` does not implement any method
+               // in scope named `push`
 ```
 
-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.
+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.
 
-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:
+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:
 
 ```{rust}
-let v = vec![1i, 2, 3];
+let vec = vec![1i, 2i, 3i];
+let slice = vec.as_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.)
-
-You can get the length of, iterate over, and subscript vectors just like
-arrays. In addition, (mutable) vectors can grow automatically:
+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:
 
 ```{rust}
-let mut nums = vec![1i, 2, 3];
-nums.push(4);
-println!("The length of nums is now {}", nums.len());   // Prints 4
+let vec = vec![1i, 2i, 3i];
+
+for i in vec.iter() {
+    println!("{}", i);
+}
 ```
 
-Vectors have many more useful methods.
+This code will print each number in order, on its own line.
 
-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:
+You can access a particular element of a vector, array, or slice by using
+**subscript notation**:
 
 ```{rust}
-let a = [0i, 1, 2, 3, 4];
-let middle = a.slice(1, 4);     // A slice of a: just the elements [1,2,3]
+let names = ["Graydon", "Brian", "Niko"];
 
-for e in middle.iter() {
-    println!("{}", e);          // Prints 1, 2, 3
-}
+println!("The second name is: {}", names[1]);
 ```
 
-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.
+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`.
 
-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
+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
 input from the keyboard. You can't have a guessing game without the ability to
 guess!
 

branches/auto/src/doc/reference.md

@@ -341,7 +341,7 @@ following forms:
   escaped in order to denote its ASCII encoding `0x5C`.
 
 Raw byte string literals do not process any escapes. They start with the
-character `U+0072` (`r`), followed by `U+0062` (`b`), followed by zero or more
+character `U+0062` (`b`), followed by `U+0072` (`r`), followed by zero or more
 of the character `U+0023` (`#`), and a `U+0022` (double-quote) character. The
 _raw string body_ is not defined in the EBNF grammar above: it can contain any
 sequence of ASCII characters and is terminated only by another `U+0022`
@@ -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`)
+* Reading data from private fields (`std::repr`, `format!("{:?}", x)`)
 * Leaks due to reference count cycles, even in the global heap
 * Exiting without calling destructors
 * Sending signals
@@ -2279,6 +2279,8 @@ 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`
@@ -2293,6 +2295,8 @@ 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,6 +317,8 @@ 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,6 +77,7 @@ 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,6 +412,9 @@ 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,6 +33,7 @@ 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,7 +101,6 @@ 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> {
     }
 }
 
-#[cfg(not(stage0))]
-impl<T> IndexMut<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> {
     #[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,6 +2154,7 @@ impl<T> Vec<T> {
     }
 }
 
+
 #[cfg(test)]
 mod tests {
     extern crate test;

branches/auto/src/libcore/intrinsics.rs

@@ -58,21 +58,17 @@ 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;
@@ -331,6 +327,8 @@ 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.