---

yaml
---
r: 152691
b: refs/heads/try2
c: 0564141
h: refs/heads/master
i:
  152689: ad8e8d6
  152687: 666649a
v: v3

Author: brson

[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: 282705c7842713d9809a9fb53223c1e40c3fe860
+refs/heads/try2: 05641413a766b8cbd2315eeb6258df289f0737d5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiler-rt

@@ -1 +1 @@
-Subproject commit 62a4ca6055ad6fda8faf767b93b5736dcdfb7013
+Subproject commit 7b97b8468f0614072cf3299fa8c51e85f609316f

branches/try2/src/compiletest/runtest.rs

@@ -1269,7 +1269,7 @@ fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path {
 
 fn aux_output_dir_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    match f.filename().map(|s| Vec::from_slice(s).append(b".libaux")) {
+    match f.filename().map(|s| Vec::from_slice(s).append(bytes!(".libaux"))) {
         Some(v) => f.set_filename(v),
         None => ()
     }
@@ -1490,7 +1490,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
         (*p).clone()
     } else {
         let stem = p.filestem().unwrap();
-        p.with_filename(Vec::from_slice(stem).append(b"-").append(suffix.as_bytes()))
+        p.with_filename(Vec::from_slice(stem).append(bytes!("-")).append(suffix.as_bytes()))
     }
 }
 

branches/try2/src/doc/complement-cheatsheet.md

@@ -76,7 +76,7 @@ character.
 ~~~
 use std::str;
 
-let x = b"Hello \xF0\x90\x80World!";
+let x = bytes!(72u8,"ello ",0xF0,0x90,0x80,"World!");
 let y = str::from_utf8_lossy(x);
 ~~~
 

branches/try2/src/doc/guide-testing.md

@@ -4,7 +4,7 @@
 
 To create test functions, add a `#[test]` attribute like this:
 
-~~~test_harness
+~~~
 fn return_two() -> int {
     2
 }
@@ -37,7 +37,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 Rust has built in support for simple unit testing. Functions can be
 marked as unit tests using the `test` attribute.
 
-~~~test_harness
+~~~
 #[test]
 fn return_none_if_empty() {
     // ... test code ...
@@ -55,7 +55,7 @@ other (`assert_eq`, ...) means, then the test fails.
 When compiling a crate with the `--test` flag `--cfg test` is also
 implied, so that tests can be conditionally compiled.
 
-~~~test_harness
+~~~
 #[cfg(test)]
 mod tests {
     #[test]
@@ -80,11 +80,11 @@ Tests that are intended to fail can be annotated with the
 task to fail then the test will be counted as successful; otherwise it
 will be counted as a failure. For example:
 
-~~~test_harness
+~~~
 #[test]
 #[should_fail]
 fn test_out_of_bounds_failure() {
-    let v: &[int] = [];
+    let v: [int] = [];
     v[0];
 }
 ~~~
@@ -204,22 +204,26 @@ amount.
 
 For example:
 
-~~~test_harness
+~~~
+# #![allow(unused_imports)]
 extern crate test;
 
+use std::slice;
 use test::Bencher;
 
 #[bench]
 fn bench_sum_1024_ints(b: &mut Bencher) {
-    let v = Vec::from_fn(1024, |n| n);
-    b.iter(|| v.iter().fold(0, |old, new| old + *new));
+    let v = slice::from_fn(1024, |n| n);
+    b.iter(|| {v.iter().fold(0, |old, new| old + *new);} );
 }
 
 #[bench]
 fn initialise_a_vector(b: &mut Bencher) {
-    b.iter(|| Vec::from_elem(1024, 0u64));
+    b.iter(|| {slice::from_elem(1024, 0u64);} );
     b.bytes = 1024 * 8;
 }
+
+# fn main() {}
 ~~~
 
 The benchmark runner will calibrate measurement of the benchmark
@@ -262,16 +266,19 @@ benchmarking what one expects. For example, the compiler might
 recognize that some calculation has no external effects and remove
 it entirely.
 
-~~~test_harness
+~~~
+# #![allow(unused_imports)]
 extern crate test;
 use test::Bencher;
 
 #[bench]
 fn bench_xor_1000_ints(b: &mut Bencher) {
     b.iter(|| {
-        range(0, 1000).fold(0, |old, new| old ^ new);
-    });
+            range(0, 1000).fold(0, |old, new| old ^ new);
+        });
 }
+
+# fn main() {}
 ~~~
 
 gives the following results
@@ -290,11 +297,8 @@ cannot remove the computation entirely. This could be done for the
 example above by adjusting the `bh.iter` call to
 
 ~~~
-# struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;
-b.iter(|| {
-    // note lack of `;` (could also use an explicit `return`).
-    range(0, 1000).fold(0, |old, new| old ^ new)
-});
+# struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let bh = X;
+bh.iter(|| range(0, 1000).fold(0, |old, new| old ^ new))
 ~~~
 
 Or, the other option is to call the generic `test::black_box`
@@ -305,10 +309,10 @@ forces it to consider any argument as used.
 extern crate test;
 
 # fn main() {
-# struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;
-b.iter(|| {
-    test::black_box(range(0, 1000).fold(0, |old, new| old ^ new));
-});
+# struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let bh = X;
+bh.iter(|| {
+        test::black_box(range(0, 1000).fold(0, |old, new| old ^ new));
+    });
 # }
 ~~~
 

branches/try2/src/doc/index.md

@@ -67,12 +67,22 @@ li {list-style-type: none; }
 
 * [The `rustdoc` manual](rustdoc.html)
 
-# External resources
+# External documentation
 
-* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/)
+* [Rust for Rubyists] - An excellent introduction for Rust; not just for Rubyists.
+* [Rust by Example] - Short examples of common tasks in Rust.
+* [The Rust wiki](http://github.com/rust-lang/rust/wiki)
+
+[Rust for Rubyists]: http://www.rustforrubyists.com/
+[Rust by Example]: http://rustbyexample.com/
+
+# Community
+
+* [Reddit](http://reddit.com/r/rust)
+* [Stack Overflow](http://stackoverflow.com/questions/tagged/rust)
+* The Rust IRC channels on [irc.mozilla.org](http://irc.mozilla.org/):
     * [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) - general discussion
     * [`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev) - game development
     * [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals) - compiler and libraries
     * [`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev) - operating system development
-* The Rust community on [Reddit](http://reddit.com/r/rust)
-* The Rust [wiki](http://github.com/rust-lang/rust/wiki)
+

branches/try2/src/doc/rust.md

@@ -234,7 +234,7 @@ rule. A literal is a form of constant expression, so is evaluated (primarily)
 at compile time.
 
 ~~~~ {.ebnf .gram}
-literal : string_lit | char_lit | byte_string_lit | byte_lit | num_lit ;
+literal : string_lit | char_lit | num_lit ;
 ~~~~
 
 #### Character and string literals
@@ -244,17 +244,17 @@ char_lit : '\x27' char_body '\x27' ;
 string_lit : '"' string_body * '"' | 'r' raw_string ;
 
 char_body : non_single_quote
-          | '\x5c' [ '\x27' | common_escape | unicode_escape ] ;
+          | '\x5c' [ '\x27' | common_escape ] ;
 
 string_body : non_double_quote
-            | '\x5c' [ '\x22' | common_escape | unicode_escape ] ;
+            | '\x5c' [ '\x22' | common_escape ] ;
 raw_string : '"' raw_string_body '"' | '#' raw_string '#' ;
 
 common_escape : '\x5c'
               | 'n' | 'r' | 't' | '0'
               | 'x' hex_digit 2
-unicode_escape : 'u' hex_digit 4
-               | 'U' hex_digit 8 ;
+              | 'u' hex_digit 4
+              | 'U' hex_digit 8 ;
 
 hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
@@ -294,7 +294,7 @@ the following forms:
     escaped in order to denote *itself*.
 
 Raw string literals do not process any escapes. They start with the character
-`U+0072` (`r`), followed by zero or more of the character `U+0023` (`#`) and a
+`U+0072` (`r`), followed 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 Unicode characters and is
 terminated only by another `U+0022` (double-quote) character, followed by the
@@ -319,78 +319,6 @@ r##"foo #"# bar"##;                // foo #"# bar
 "\\x52"; r"\x52";                  // \x52
 ~~~~
 
-#### Byte and byte string literals
-
-~~~~ {.ebnf .gram}
-byte_lit : 'b' '\x27' byte_body '\x27' ;
-byte_string_lit : 'b' '"' string_body * '"' | 'b' 'r' raw_byte_string ;
-
-byte_body : ascii_non_single_quote
-          | '\x5c' [ '\x27' | common_escape ] ;
-
-byte_string_body : ascii_non_double_quote
-            | '\x5c' [ '\x22' | common_escape ] ;
-raw_byte_string : '"' raw_byte_string_body '"' | '#' raw_byte_string '#' ;
-
-~~~~
-
-A _byte literal_ is a single ASCII character (in the `U+0000` to `U+007F` range)
-enclosed within two `U+0027` (single-quote) characters,
-with the exception of `U+0027` itself,
-which must be _escaped_ by a preceding U+005C character (`\`),
-or a single _escape_.
-It is equivalent to a `u8` unsigned 8-bit integer _number literal_.
-
-A _byte string literal_ is a sequence of ASCII characters and _escapes_
-enclosed within two `U+0022` (double-quote) characters,
-with the exception of `U+0022` itself,
-which must be _escaped_ by a preceding `U+005C` character (`\`),
-or a _raw byte string literal_.
-It is equivalent to a `&'static [u8]` borrowed vectior unsigned 8-bit integers.
-
-Some additional _escapes_ are available in either byte or non-raw byte string
-literals. An escape starts with a `U+005C` (`\`) and continues with one of
-the following forms:
-
-  * An _byte escape_ escape starts with `U+0078` (`x`) and is
-    followed by exactly two _hex digits_. It denotes the byte
-    equal to the provided hex value.
-  * A _whitespace escape_ is one of the characters `U+006E` (`n`), `U+0072`
-    (`r`), or `U+0074` (`t`), denoting the bytes values `0x0A` (ASCII LF),
-    `0x0D` (ASCII CR) or `0x09` (ASCII HT) respectively.
-  * The _backslash escape_ is the character `U+005C` (`\`) which must be
-    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 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` (double-quote) character, followed by the
-same number of `U+0023` (`#`) characters that preceded the opening `U+0022`
-(double-quote) character.
-A raw byte string literal can not contain any non-ASCII byte.
-
-All characters contained in the raw string body represent their ASCII encoding,
-the characters `U+0022` (double-quote) (except when followed by at least as
-many `U+0023` (`#`) characters as were used to start the raw string literal) or
-`U+005C` (`\`) do not have any special meaning.
-
-Examples for byte string literals:
-
-~~~~
-b"foo"; br"foo";                     // foo
-b"\"foo\""; br#""foo""#;             // "foo"
-
-b"foo #\"# bar";
-br##"foo #"# bar"##;                 // foo #"# bar
-
-b"\x52"; b"R"; br"R";                // R
-b"\\x52"; br"\x52";                  // \x52
-~~~~
-
 #### Number literals
 
 ~~~~ {.ebnf .gram}

branches/try2/src/doc/rustdoc.md

@@ -171,18 +171,6 @@ You can specify that the code block should be compiled but not run with the
 ```
 ~~~
 
-Lastly, you can specify that a code block be compiled as if `--test`
-were passed to the compiler using the `test_harness` directive.
-
-~~~md
-```test_harness
-#[test]
-fn foo() {
-    fail!("oops! (will run & register as failure)")
-}
-```
-~~~
-
 Rustdoc also supplies some extra sugar for helping with some tedious
 documentation examples. If a line is prefixed with `# `, then the line
 will not show up in the HTML documentation, but it will be used when