---

yaml
---
r: 100859
b: refs/heads/snap-stage3
c: 615536a
h: refs/heads/master
i:
  100857: 0b02b05
  100855: 7c568d5
v: v3

Author: luqmana

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e3b1f3c443c048913e2d573fcc5a9c2be3484a78
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 49ba513c78e6430e55e5478f478a157e085a639a
+refs/heads/snap-stage3: 615536a265124550cc94b6c66c64bdb6752391f1
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/platform.mk

@@ -350,7 +350,7 @@ CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabi := -Wl,--export-dynamic,--dynamic-
 CFG_GCCISH_PRE_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_arm-unknown-linux-gnueabi := -Wl,-no-whole-archive
 CFG_DEF_SUFFIX_arm-unknown-linux-gnueabi := .linux.def
-CFG_LLC_FLAGS_arm-unknown-linux-gnueabi := -arm-enable-ehabi -arm-enable-ehabi-descriptors
+CFG_LLC_FLAGS_arm-unknown-linux-gnueabi :=
 CFG_INSTALL_NAME_arm-unknown-linux-gnueabi =
 CFG_LIBUV_LINK_FLAGS_arm-unknown-linux-gnueabi =
 CFG_EXE_SUFFIX_arm-unknown-linux-gnueabi :=

branches/snap-stage3/src/doc/rustdoc.md

@@ -100,29 +100,34 @@ rustdoc --test crate.rs
 
 ## Defining tests
 
-Rust documentation currently uses the markdown format, and rustdoc treats all
-code blocks as testable-by-default. In order to not run a test over a block of
-code, the `ignore` string can be added to the three-backtick form of markdown
-code block.
+Rust documentation currently uses the markdown format, and code blocks can refer
+to any piece of code-related documentation, which isn't always rust. Because of
+this, only code blocks with the language of "rust" will be considered for
+testing.
 
 ~~~
-```
+```rust
 // This is a testable code block
 ```
 
-```ignore
+```
 // This is not a testable code block
 ```
 
-    // This is a testable code block (4-space indent)
+    // This is not a testable code block (4-space indent)
 ~~~
 
-In addition to the `ignore` directive, you can specify that the test's execution
-should fail with the `should_fail` directive.
+In addition to only testing "rust"-language code blocks, there are additional
+specifiers that can be used to dictate how a code block is tested:
 
 ~~~
-```should_fail
-// This code block is expected to generate a failure when run
+```rust,ignore
+// This code block is ignored by rustdoc, but is passed through to the test
+// harness
+```
+
+```rust,should_fail
+// This code block is expected to generate a failure
 ```
 ~~~
 
@@ -138,7 +143,7 @@ that one can still write things like `#[deriving(Eq)]`).
 # the doc-generating tool.  In order to display them anyway in this particular
 # case, the character following the leading '#' is not a usual space like in
 # these first five lines but a non breakable one.
-#
+# 
 # // showing 'fib' in this documentation would just be tedious and detracts from
 # // what's actualy being documented.
 # fn fib(n: int) { n + 2 }
@@ -164,6 +169,9 @@ rustdoc --test lib.rs --test-args 'foo'
 
 // See what's possible when running tests
 rustdoc --test lib.rs --test-args '--help'
+
+// Run all ignored tests
+rustdoc --test lib.rs --test-args '--ignored'
 ~~~
 
 When testing a library, code examples will often show how functions are used,

branches/snap-stage3/src/libextra/json.rs

@@ -30,7 +30,7 @@ An object is a series of string keys mapping to values, in `"key": value` format
 Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
 A simple JSON document encoding a person, his/her age, address and phone numbers could look like:
 
-```ignore
+```
 {
     "FirstName": "John",
     "LastName": "Doe",

branches/snap-stage3/src/libextra/stats.rs

@@ -341,7 +341,7 @@ pub fn write_5_number_summary(w: &mut io::Writer,
 /// As an example, the summary with 5-number-summary `(min=15, q1=17, med=20, q3=24, max=31)` might
 /// display as:
 ///
-/// ~~~~ignore
+/// ~~~~
 ///   10 |        [--****#******----------]          | 40
 /// ~~~~
 

branches/snap-stage3/src/libglob/lib.rs

@@ -67,7 +67,7 @@ pub struct Paths {
 ///
 /// The above code will print:
 ///
-/// ```ignore
+/// ```
 /// /media/pictures/kittens.jpg
 /// /media/pictures/puppies.jpg
 /// ```

branches/snap-stage3/src/librustdoc/html/markdown.rs

@@ -172,23 +172,21 @@ pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
 pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
     extern fn block(_ob: *buf, text: *buf, lang: *buf, opaque: *libc::c_void) {
         unsafe {
-            if text.is_null() { return }
-            let (shouldfail, ignore) = if lang.is_null() {
-                (false, false)
-            } else {
+            if text.is_null() || lang.is_null() { return }
+            let (test, shouldfail, ignore) =
                 vec::raw::buf_as_slice((*lang).data,
                                        (*lang).size as uint, |lang| {
                     let s = str::from_utf8(lang).unwrap();
-                    (s.contains("should_fail"), s.contains("ignore"))
-                })
-            };
-            if ignore { return }
+                    (s.contains("rust"), s.contains("should_fail"),
+                     s.contains("ignore"))
+                });
+            if !test { return }
             vec::raw::buf_as_slice((*text).data, (*text).size as uint, |text| {
                 let tests: &mut ::test::Collector = intrinsics::transmute(opaque);
                 let text = str::from_utf8(text).unwrap();
                 let mut lines = text.lines().map(|l| stripped_filtered_line(l).unwrap_or(l));
                 let text = lines.to_owned_vec().connect("\n");
-                tests.add_test(text, shouldfail);
+                tests.add_test(text, ignore, shouldfail);
             })
         }
     }

branches/snap-stage3/src/librustdoc/test.rs

@@ -94,7 +94,7 @@ pub fn run(input: &str, matches: &getopts::Matches) -> int {
     0
 }
 
-fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool) {
+fn runtest(test: &str, cratename: &str, libs: HashSet<Path>) {
     let test = maketest(test, cratename);
     let parsesess = parse::new_parse_sess();
     let input = driver::StrInput(test);
@@ -130,10 +130,9 @@ fn runtest(test: &str, cratename: &str, libs: HashSet<Path>, should_fail: bool)
     match out {
         Err(e) => fail!("couldn't run the test: {}", e),
         Ok(out) => {
-            if should_fail && out.status.success() {
-                fail!("test executable succeeded when it should have failed");
-            } else if !should_fail && !out.status.success() {
-                fail!("test executable failed:\n{}", str::from_utf8(out.error));
+            if !out.status.success() {
+                fail!("test executable failed:\n{}",
+                      str::from_utf8(out.error));
             }
         }
     }
@@ -170,7 +169,7 @@ pub struct Collector {
 }
 
 impl Collector {
-    pub fn add_test(&mut self, test: &str, should_fail: bool) {
+    pub fn add_test(&mut self, test: &str, ignore: bool, should_fail: bool) {
         let test = test.to_owned();
         let name = format!("{}_{}", self.names.connect("::"), self.cnt);
         self.cnt += 1;
@@ -181,11 +180,11 @@ impl Collector {
         self.tests.push(test::TestDescAndFn {
             desc: test::TestDesc {
                 name: test::DynTestName(name),
-                ignore: false,
-                should_fail: false, // compiler failures are test failures
+                ignore: ignore,
+                should_fail: should_fail,
             },
             testfn: test::DynTestFn(proc() {
-                runtest(test, cratename, libs, should_fail);
+                runtest(test, cratename, libs);
             }),
         });
     }

branches/snap-stage3/src/libstd/comm/mod.rs

@@ -61,7 +61,7 @@
 //! let (port, chan) = Chan::new();
 //! spawn(proc() {
 //!     chan.send(10);
-//! });
+//! })
 //! assert_eq!(port.recv(), 10);
 //!
 //! // Create a shared channel which can be sent along from many tasks

branches/snap-stage3/src/libstd/fmt/mod.rs

@@ -82,7 +82,7 @@ function, but the `format!` macro is a syntax extension which allows it to
 leverage named parameters. Named parameters are listed at the end of the
 argument list and have the syntax:
 
-```ignore
+```
 identifier '=' expression
 ```
 
@@ -107,7 +107,7 @@ and if all references to one argument do not provide a type, then the format `?`
 is used (the type's rust-representation is printed). For example, this is an
 invalid format string:
 
-```ignore
+```
 {0:d} {0:s}
 ```
 
@@ -123,7 +123,7 @@ must have the type `uint`. Although a `uint` can be printed with `{:u}`, it is
 illegal to reference an argument as such. For example, this is another invalid
 format string:
 
-```ignore
+```
 {:.*s} {0:u}
 ```
 
@@ -334,7 +334,7 @@ This example is the equivalent of `{0:s}` essentially.
 The select method is a switch over a `&str` parameter, and the parameter *must*
 be of the type `&str`. An example of the syntax is:
 
-```ignore
+```
 {0, select, male{...} female{...} other{...}}
 ```
 
@@ -353,7 +353,7 @@ The plural method is a switch statement over a `uint` parameter, and the
 parameter *must* be a `uint`. A plural method in its full glory can be specified
 as:
 
-```ignore
+```
 {0, plural, offset=1 =1{...} two{...} many{...} other{...}}
 ```
 
@@ -381,7 +381,7 @@ should not be too alien. Arguments are formatted with python-like syntax,
 meaning that arguments are surrounded by `{}` instead of the C-like `%`. The
 actual grammar for the formatting syntax is:
 
-```ignore
+```
 format_string := <text> [ format <text> ] *
 format := '{' [ argument ] [ ':' format_spec ] [ ',' function_spec ] '}'
 argument := integer | identifier

branches/snap-stage3/src/libstd/io/comm_adapters.rs

@@ -22,16 +22,12 @@ use vec::{bytes, CloneableVector, MutableVector, ImmutableVector};
 /// # Example
 ///
 /// ```
-/// use std::io::PortReader;
-///
-/// let (port, chan) = Chan::new();
-/// # drop(chan);
-/// let mut reader = PortReader::new(port);
+/// let reader = PortReader::new(port);
 ///
 /// let mut buf = ~[0u8, ..100];
 /// match reader.read(buf) {
-///     Ok(nread) => println!("Read {} bytes", nread),
-///     Err(e) => println!("read error: {}", e),
+///     Some(nread) => println!("Read {} bytes", nread),
+///     None => println!("At the end of the stream!")
 /// }
 /// ```
 pub struct PortReader {
@@ -87,12 +83,7 @@ impl Reader for PortReader {
 /// # Example
 ///
 /// ```
-/// # #[allow(unused_must_use)];
-/// use std::io::ChanWriter;
-///
-/// let (port, chan) = Chan::new();
-/// # drop(port);
-/// let mut writer = ChanWriter::new(chan);
+/// let writer = ChanWriter::new(chan);
 /// writer.write("hello, world".as_bytes());
 /// ```
 pub struct ChanWriter {

branches/snap-stage3/src/libstd/io/net/unix.rs

@@ -91,18 +91,15 @@ impl UnixListener {
     /// # Example
     ///
     /// ```
-    /// # fn main() {}
-    /// # fn foo() {
-    /// # #[allow(unused_must_use)];
     /// use std::io::net::unix::UnixListener;
-    /// use std::io::{Listener, Acceptor};
+    /// use std::io::Listener;
     ///
-    /// let server = Path::new("/path/to/my/socket");
-    /// let stream = UnixListener::bind(&server);
-    /// for mut client in stream.listen().incoming() {
+    /// let server = Path::new("path/to/my/socket");
+    /// let mut stream = UnixListener::bind(&server);
+    /// for client in stream.incoming() {
+    ///     let mut client = client;
     ///     client.write([1, 2, 3, 4]);
     /// }
-    /// # }
     /// ```
     pub fn bind<P: ToCStr>(path: &P) -> IoResult<UnixListener> {
         LocalIo::maybe_raise(|io| {

branches/snap-stage3/src/libstd/io/util.rs

@@ -24,18 +24,7 @@ impl<R: Reader> LimitReader<R> {
     pub fn new(r: R, limit: uint) -> LimitReader<R> {
         LimitReader { limit: limit, inner: r }
     }
-
-    /// Consumes the `LimitReader`, returning the underlying `Reader`.
     pub fn unwrap(self) -> R { self.inner }
-
-    /// Returns the number of bytes that can be read before the `LimitReader`
-    /// will return EOF.
-    ///
-    /// # Note
-    ///
-    /// The reader may reach EOF after reading fewer bytes than indicated by
-    /// this method if the underlying reader reaches EOF.
-    pub fn limit(&self) -> uint { self.limit }
 }
 
 impl<R: Reader> Reader for LimitReader<R> {
@@ -201,7 +190,7 @@ mod test {
     use prelude::*;
 
     #[test]
-    fn test_limit_reader_unlimited() {
+    fn test_bounded_reader_unlimited() {
         let mut r = MemReader::new(~[0, 1, 2]);
         {
             let mut r = LimitReader::new(r.by_ref(), 4);
@@ -210,7 +199,7 @@ mod test {
     }
 
     #[test]
-    fn test_limit_reader_limited() {
+    fn test_bound_reader_limited() {
         let mut r = MemReader::new(~[0, 1, 2]);
         {
             let mut r = LimitReader::new(r.by_ref(), 2);
@@ -219,17 +208,6 @@ mod test {
         assert_eq!(~[2], r.read_to_end().unwrap());
     }
 
-    #[test]
-    fn test_limit_reader_limit() {
-        let r = MemReader::new(~[0, 1, 2]);
-        let mut r = LimitReader::new(r, 3);
-        assert_eq!(3, r.limit());
-        assert_eq!(0, r.read_byte().unwrap());
-        assert_eq!(2, r.limit());
-        assert_eq!(~[1, 2], r.read_to_end().unwrap());
-        assert_eq!(0, r.limit());
-    }
-
     #[test]
     fn test_null_writer() {
         let mut s = NullWriter;

branches/snap-stage3/src/libstd/kinds.rs

@@ -69,9 +69,7 @@ pub mod marker {
     /// Given a struct `S` that includes a type parameter `T`
     /// but does not actually *reference* that type parameter:
     ///
-    /// ```ignore
-    /// use std::cast;
-    ///
+    /// ```
     /// struct S<T> { x: *() }
     /// fn get<T>(s: &S<T>) -> T {
     ///    unsafe {
@@ -111,8 +109,6 @@ pub mod marker {
     /// but does not actually *reference* that type parameter:
     ///
     /// ```
-    /// use std::cast;
-    ///
     /// struct S<T> { x: *() }
     /// fn get<T>(s: &S<T>, v: T) {
     ///    unsafe {
@@ -151,8 +147,7 @@ pub mod marker {
     /// "interior" mutability:
     ///
     /// ```
-    /// pub struct Cell<T> { priv value: T }
-    /// # fn main() {}
+    /// struct Cell<T> { priv value: T }
     /// ```
     ///
     /// The type system would infer that `value` is only read here and