---

yaml
---
r: 207963
b: refs/heads/snap-stage3
c: 3a4a1e5
h: refs/heads/master
i:
  207961: a3f69ac
  207959: 352fd52
v: v3

Author: Nick Hamann

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: a979efc2f961c2cf8d7afa57b905e73349b8f476
+refs/heads/snap-stage3: 3a4a1e5f386137514b91c76ad06d909789bcd549
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/compiletest/compiletest.rs

@@ -269,7 +269,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         run_ignored: config.run_ignored,
         logfile: config.logfile.clone(),
         run_tests: true,
-        bench_benchmarks: true,
+        run_benchmarks: true,
         nocapture: env::var("RUST_TEST_NOCAPTURE").is_ok(),
         color: test::AutoColor,
     }

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

@@ -2044,21 +2044,21 @@ A complete list of the built-in language items will be added in the future.
 
 ### Inline attributes
 
-The inline attribute suggests that the compiler should place a copy of
-the function or static in the caller, rather than generating code to
-call the function or access the static where it is defined.
+The inline attribute is used to suggest to the compiler to perform an inline
+expansion and place a copy of the function or static in the caller rather than
+generating code to call the function or access the static where it is defined.
 
 The compiler automatically inlines functions based on internal heuristics.
-Incorrectly inlining functions can actually make the program slower, so it
+Incorrectly inlining functions can actually making the program slower, so it
 should be used with care.
 
 Immutable statics are always considered inlineable unless marked with
 `#[inline(never)]`. It is undefined whether two different inlineable statics
 have the same memory address. In other words, the compiler is free to collapse
 duplicate inlineable statics together.
 
-`#[inline]` and `#[inline(always)]` always cause the function to be serialized
-into the crate metadata to allow cross-crate inlining.
+`#[inline]` and `#[inline(always)]` always causes the function to be serialized
+into crate metadata to allow cross-crate inlining.
 
 There are three different types of inline attributes:
 

branches/snap-stage3/src/doc/trpl/README.md

@@ -40,11 +40,6 @@ want to dive in with a project, or ‘Syntax and Semantics’ if you prefer to
 start small, and learn a single concept thoroughly before moving onto the next.
 Copious cross-linking connects these parts together.
 
-### Contributing
-
-The source files from which this book is generated can be found on Github:
-[github.com/rust-lang/rust/tree/master/src/doc/trpl](https://github.com/rust-lang/rust/tree/master/src/doc/trpl)
-
 ## A brief introduction to Rust
 
 Is Rust a language you might be interested in? Let’s examine a few small code

branches/snap-stage3/src/doc/trpl/SUMMARY.md

@@ -64,6 +64,5 @@
     * [Benchmark Tests](benchmark-tests.md)
     * [Box Syntax and Patterns](box-syntax-and-patterns.md)
     * [Slice Patterns](slice-patterns.md)
-    * [Associated Constants](associated-constants.md)
 * [Glossary](glossary.md)
 * [Academic Research](academic-research.md)

branches/snap-stage3/src/doc/trpl/associated-constants.md

@@ -70,7 +70,8 @@ This prints `something else`
 
 # Bindings
 
-You can bind values to names with `@`:
+If you’re matching multiple things, via a `|` or a `...`, you can bind
+the value to a name with `@`:
 
 ```rust
 let x = 1;
@@ -81,36 +82,7 @@ match x {
 }
 ```
 
-This prints `got a range element 1`. This is useful when you want to
-do a complicated match of part of a data structure:
-
-```rust
-#[derive(Debug)]
-struct Person {
-    name: Option<String>,
-}
-
-let name = "Steve".to_string();
-let mut x: Option<Person> = Some(Person { name: Some(name) });
-match x {
-    Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a),
-    _ => {}
-}
-```
-
-This prints `Some("Steve")`: We’ve bound the inner `name` to `a`.
-
-If you use `@` with `|`, you need to make sure the name is bound in each part
-of the pattern:
-
-```rust
-let x = 5;
-
-match x {
-    e @ 1 ... 5 | e @ 8 ... 10 => println!("got a range element {}", e),
-    _ => println!("anything"),
-}
-```
+This prints `got a range element 1`.
 
 # Ignoring variants
 

branches/snap-stage3/src/doc/trpl/patterns.md

@@ -1004,7 +1004,11 @@ pub trait SliceConcatExt<T: ?Sized, U> {
     /// # Examples
     ///
     /// ```
-    /// assert_eq!(["hello", "world"].concat(), "helloworld");
+    /// let v = vec!["hello", "world"];
+    ///
+    /// let s: String = v.concat();
+    ///
+    /// println!("{}", s); // prints "helloworld"
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn concat(&self) -> U;
@@ -1014,7 +1018,11 @@ pub trait SliceConcatExt<T: ?Sized, U> {
     /// # Examples
     ///
     /// ```
-    /// assert_eq!(["hello", "world"].connect(" "), "hello world");
+    /// let v = vec!["hello", "world"];
+    ///
+    /// let s: String = v.connect(" ");
+    ///
+    /// println!("{}", s); // prints "hello world"
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn connect(&self, sep: &T) -> U;

branches/snap-stage3/src/libcollections/slice.rs

@@ -1777,11 +1777,6 @@ impl<T> Iterator for IntoIter<T> {
         let exact = diff / (if size == 0 {1} else {size});
         (exact, Some(exact))
     }
-
-    #[inline]
-    fn count(self) -> usize {
-        self.size_hint().0
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

branches/snap-stage3/src/libcollections/vec.rs

@@ -542,11 +542,6 @@ fn test_split_off() {
     assert_eq!(vec2, [5, 6]);
 }
 
-#[test]
-fn test_into_iter_count() {
-    assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
-}
-
 #[bench]
 fn bench_new(b: &mut Bencher) {
     b.iter(|| {