---

yaml
---
r: 195347
b: refs/heads/snap-stage3
c: 1accaa9
h: refs/heads/master
i:
  195345: 6c875e7
  195343: 8590807
v: v3

Author: petrochenkov

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 14192d6df5cc714e5c9a3ca70b08f2514d977be2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 92f3d9a6b46a116a48b0dd35b66c8f66786296d6
+refs/heads/snap-stage3: 1accaa9f86002e95c1d0a677349ab033ec6dd2e2
 refs/heads/try: 961e0358e1a5c0faaef606e31e9965742c1643bf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/AUTHORS.txt

@@ -606,7 +606,7 @@ Peter Schuller <[email protected]>
 Peter Williams <[email protected]>
 Peter Zotov <[email protected]>
 Petter Remen <[email protected]>
-Phil Dawes <[email protected]>
+Phil Dawes <[email protected]>
 Phil Ruffwind <[email protected]>
 Philip Munksgaard <[email protected]>
 Philipp Brüschweiler <[email protected]>

branches/snap-stage3/configure

@@ -404,7 +404,7 @@ case $CFG_OSTYPE in
         CFG_OSTYPE=pc-windows-gnu
         ;;
 
-# Thad's Cygwin identifers below
+# Thad's Cygwin identifiers below
 
 #   Vista 32 bit
     CYGWIN_NT-6.0)

branches/snap-stage3/mk/platform.mk

@@ -179,7 +179,7 @@ define CFG_MAKE_TOOLCHAIN
 
   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 
-  # On Bitrig, we need the relocation model to be PIC for everthing
+  # On Bitrig, we need the relocation model to be PIC for everything
   ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
     LLVM_MC_RELOCATION_MODEL="pic"
   else

branches/snap-stage3/mk/target.mk

@@ -132,7 +132,7 @@ endef
 # on $$(TSREQ$(1)_T_$(2)_H_$(3)), to ensure that no products will be
 # put into the target area until after the get-snapshot.py script has
 # had its chance to clean it out; otherwise the other products will be
-# inadvertantly included in the clean out.
+# inadvertently included in the clean out.
 SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD))/rustc$(X_$(CFG_BUILD))
 
 define TARGET_HOST_RULES

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

@@ -13,6 +13,7 @@
     * [Looping](looping.md)
     * [Strings](strings.md)
     * [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md)
+    * [Standard Input](standard-input.md)
 * [Intermediate Rust](intermediate.md)
     * [Crates and Modules](crates-and-modules.md)
     * [Testing](testing.md)

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

@@ -170,7 +170,7 @@ let obj = Box::new(graph) as Box<Graph>;
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ```
 
-We can’t create a trait object like this, becuase we don’t know the associated
+We can’t create a trait object like this, because we don’t know the associated
 types. Instead, we can write this:
 
 ```rust

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

@@ -517,7 +517,7 @@ can be useful when changing some options, or when writing a macro.
 
 ### Re-exports
 
-`rustdoc` will show the documentation for a public re-export in both places:
+`rustdoc` will show the documentation for a publc re-export in both places:
 
 ```ignore
 extern crate foo;
@@ -529,7 +529,7 @@ This will create documentation for bar both inside the documentation for the
 crate `foo`, as well as the documentation for your crate. It will use the same
 documentation in both places.
 
-This behavior can be supressed with `no_inline`:
+This behavior can be suppressed with `no_inline`:
 
 ```ignore
 extern crate foo;

branches/snap-stage3/src/doc/trpl/standard-input.md

@@ -0,0 +1,166 @@
+% Standard Input
+
+Getting input from the keyboard is pretty easy, but uses some things
+we haven't seen before. Here's a simple program that reads some input,
+and then prints it back out:
+
+```{rust,ignore}
+# #![feature(old_io)]
+fn main() {
+    println!("Type something!");
+
+    let input = std::old_io::stdin().read_line().ok().expect("Failed to read line");
+
+    println!("{}", input);
+}
+```
+
+Let's go over these chunks, one by one:
+
+```{rust,ignore}
+std::old_io::stdin();
+```
+
+This calls a function, `stdin()`, that lives inside the `std::old_io` module. As
+you can imagine, everything in `std` is provided by Rust, the 'standard
+library.' We'll talk more about the module system later.
+
+Since writing the fully qualified name all the time is annoying, we can use
+the `use` statement to import it in:
+
+```{rust}
+# #![feature(old_io)]
+use std::old_io::stdin;
+
+stdin();
+```
+
+However, it's considered better practice to not import individual functions, but
+to import the module, and only use one level of qualification:
+
+```{rust}
+# #![feature(old_io)]
+use std::old_io;
+
+old_io::stdin();
+```
+
+Let's update our example to use this style:
+
+```{rust,ignore}
+use std::old_io;
+
+fn main() {
+    println!("Type something!");
+
+    let input = old_io::stdin().read_line().ok().expect("Failed to read line");
+
+    println!("{}", input);
+}
+```
+
+Next up:
+
+```{rust,ignore}
+.read_line()
+```
+
+The `read_line()` method can be called on the result of `stdin()` to return
+a full line of input. Nice and easy.
+
+```{rust,ignore}
+.ok().expect("Failed to read line");
+```
+
+Do you remember this code?
+
+```{rust}
+enum OptionalInt {
+    Value(i32),
+    Missing,
+}
+
+fn main() {
+    let x = OptionalInt::Value(5);
+    let y = OptionalInt::Missing;
+
+    match x {
+        OptionalInt::Value(n) => println!("x is {}", n),
+        OptionalInt::Missing => println!("x is missing!"),
+    }
+
+    match y {
+        OptionalInt::Value(n) => println!("y is {}", n),
+        OptionalInt::Missing => println!("y is missing!"),
+    }
+}
+```
+
+We had to match each time to see if we had a value or not. In this case,
+though, we _know_ that `x` has a `Value`, but `match` forces us to handle
+the `missing` case. This is what we want 99% of the time, but sometimes, we
+know better than the compiler.
+
+Likewise, `read_line()` does not return a line of input. It _might_ return a
+line of input, though it might also fail to do so. This could happen if our program
+isn't running in a terminal, but as part of a cron job, or some other context
+where there's no standard input. Because of this, `read_line` returns a type
+very similar to our `OptionalInt`: an `IoResult<T>`. We haven't talked about
+`IoResult<T>` yet because it is the *generic* form of our `OptionalInt`.
+Until then, you can think of it as being the same thing, just for any type –
+not just `i32`s.
+
+Rust provides a method on these `IoResult<T>`s called `ok()`, which does the
+same thing as our `match` statement but assumes that we have a valid value.
+We then call `expect()` on the result, which will terminate our program if we
+don't have a valid value. In this case, if we can't get input, our program
+doesn't work, so we're okay with that. In most cases, we would want to handle
+the error case explicitly. `expect()` allows us to give an error message if
+this crash happens.
+
+We will cover the exact details of how all of this works later in the Guide in
+[Error Handling]. For now, this gives you enough of a basic understanding to
+work with.
+
+Back to the code we were working on! Here's a refresher:
+
+```{rust,ignore}
+use std::old_io;
+
+fn main() {
+    println!("Type something!");
+
+    let input = old_io::stdin().read_line().ok().expect("Failed to read line");
+
+    println!("{}", input);
+}
+```
+
+With long lines like this, Rust gives you some flexibility with the whitespace.
+We _could_ write the example like this:
+
+```{rust,ignore}
+use std::old_io;
+
+fn main() {
+    println!("Type something!");
+
+    // here, we'll show the types at each step
+
+    let input = old_io::stdin() // std::old_io::stdio::StdinReader
+                  .read_line() // IoResult<String>
+                  .ok() // Option<String>
+                  .expect("Failed to read line"); // String
+
+    println!("{}", input);
+}
+```
+
+Sometimes, this makes things more readable – sometimes, less. Use your judgement
+here.
+
+That's all you need to get basic input from the standard input! It's not too
+complicated, but there are a number of small parts.
+
+
+[Error Handling]: ./error-handling.html

branches/snap-stage3/src/etc/rustup.sh

@@ -335,7 +335,7 @@ case $CFG_OSTYPE in
     MINGW32*)
         CFG_OSTYPE=pc-mingw32
         ;;
-# Thad's Cygwin identifers below
+# Thad's Cygwin identifiers below
 
 #   Vista 32 bit
     CYGWIN_NT-6.0)
@@ -437,7 +437,7 @@ CFG_TMP_DIR=$(mktemp -d 2>/dev/null \
            || create_tmp_dir)
 
 # If we're saving nightlies and we didn't specify which one, grab the latest
-# verison from the perspective of the server. Buildbot has typically finished
+# version from the perspective of the server. Buildbot has typically finished
 # building and uploading by ~8UTC, but we want to include a little buffer.
 #
 # FIXME It would be better to use the known most recent nightly that has been

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

@@ -50,8 +50,8 @@
 //!
 //! ## Iteration
 //!
-//! The slices implement `IntoIterator`. The iterator yields references to the
-//! slice elements.
+//! The slices implement `IntoIterator`. The iterators of yield references
+//! to the slice elements.
 //!
 //! ```
 //! let numbers = &[0, 1, 2];

branches/snap-stage3/src/libcore/hash/mod.rs

@@ -73,16 +73,6 @@ mod sip;
 ///
 /// The `H` type parameter is an abstract hash state that is used by the `Hash`
 /// to compute the hash.
-///
-/// If you are also implementing `Eq`, there is an additional property that
-/// is important:
-///
-/// ```text
-/// k1 == k2 -> hash(k1) == hash(k2)
-/// ```
-///
-/// In other words, if two keys are equal, their hashes should also be equal.
-/// `HashMap` and `HashSet` both rely on this behavior.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Hash {
     /// Feeds this value into the state given, updating the hasher as necessary.

branches/snap-stage3/src/libcore/iter.rs

@@ -1017,27 +1017,6 @@ impl<'a, I: Iterator + ?Sized> Iterator for &'a mut I {
                           built from an iterator over elements of type `{A}`"]
 pub trait FromIterator<A> {
     /// Build a container with elements from something iterable.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::HashSet;
-    /// use std::iter::FromIterator;
-    ///
-    /// let colors_vec = vec!["red", "red", "yellow", "blue"];
-    /// let colors_set = HashSet::<&str>::from_iter(colors_vec);
-    /// assert_eq!(colors_set.len(), 3);
-    /// ```
-    ///
-    /// `FromIterator` is more commonly used implicitly via the `Iterator::collect` method:
-    ///
-    /// ```
-    /// use std::collections::HashSet;
-    ///
-    /// let colors_vec = vec!["red", "red", "yellow", "blue"];
-    /// let colors_set = colors_vec.into_iter().collect::<HashSet<&str>>();
-    /// assert_eq!(colors_set.len(), 3);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn from_iter<T: IntoIterator<Item=A>>(iterator: T) -> Self;
 }

branches/snap-stage3/src/libcore/marker.rs

@@ -476,7 +476,7 @@ pub struct InvariantType<T>;
 /// particular, thanks to the `Reflect` bound, callers know that a
 /// function declared like `fn bar<T>(...)` will always act in
 /// precisely the same way no matter what type `T` is supplied,
-/// beacuse there are no bounds declared on `T`. (The ability for a
+/// because there are no bounds declared on `T`. (The ability for a
 /// caller to reason about what a function may do based solely on what
 /// generic bounds are declared is often called the ["parametricity
 /// property"][1].)

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

@@ -307,10 +307,7 @@ pub mod types {
                 #[derive(Copy)] pub struct sockaddr_storage {
                     pub ss_family: sa_family_t,
                     pub __ss_align: isize,
-                    #[cfg(target_pointer_width = "32")]
-                    pub __ss_pad2: [u8; 128 - 2 * 4],
-                    #[cfg(target_pointer_width = "64")]
-                    pub __ss_pad2: [u8; 128 - 2 * 8],
+                    pub __ss_pad2: [u8; 128 - 2 * (::core::isize::BYTES as usize)],
                 }
                 #[repr(C)]
                 #[derive(Copy)] pub struct sockaddr_in {

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

@@ -83,7 +83,7 @@
 //! - `Sub32` (`0d`): 4-byte unsigned integer for supplementary information.
 //!   Those two tags normally occur as the first subdocument of certain tags,
 //!   namely `Enum`, `Vec` and `Map`, to provide a variant or size information.
-//!   They can be used interchangably.
+//!   They can be used interchangeably.
 //!
 //! Predefined tags with an explicit length:
 //!

branches/snap-stage3/src/librustc_back/target/mod.rs

@@ -157,7 +157,7 @@ pub struct TargetOptions {
     /// particular running dsymutil and some other stuff like `-dead_strip`. Defaults to false.
     pub is_like_osx: bool,
     /// Whether the target toolchain is like Windows'. Only useful for compiling against Windows,
-    /// only realy used for figuring out how to find libraries, since Windows uses its own
+    /// only really used for figuring out how to find libraries, since Windows uses its own
     /// library naming convention. Defaults to false.
     pub is_like_windows: bool,
     /// Whether the target toolchain is like Android's. Only useful for compiling against Android.

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

@@ -125,7 +125,6 @@ pub struct Implementor {
     pub trait_: clean::Type,
     pub for_: clean::Type,
     pub stability: Option<clean::Stability>,
-    pub polarity: Option<clean::ImplPolarity>,
 }
 
 /// Metadata about implementations for a type.
@@ -636,11 +635,9 @@ fn write_shared(cx: &Context,
             // going on). If they're in different crates then the crate defining
             // the trait will be interested in our implementation.
             if imp.def_id.krate == did.krate { continue }
-            try!(write!(&mut f, r#""{}impl{} {}{} for {}","#,
+            try!(write!(&mut f, r#""{}impl{} {} for {}","#,
                         ConciseStability(&imp.stability),
-                        imp.generics,
-                        if imp.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
-                        imp.trait_, imp.for_));
+                        imp.generics, imp.trait_, imp.for_));
         }
         try!(writeln!(&mut f, r"];"));
         try!(writeln!(&mut f, "{}", r"
@@ -885,7 +882,6 @@ impl DocFolder for Cache {
                         trait_: i.trait_.as_ref().unwrap().clone(),
                         for_: i.for_.clone(),
                         stability: item.stability.clone(),
-                        polarity: i.polarity.clone(),
                     });
                 }
                 Some(..) | None => {}

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

@@ -86,7 +86,7 @@ impl Ord for ModuleSummary {
     }
 }
 
-// is the item considered publically visible?
+// is the item considered publicly visible?
 fn visible(item: &Item) -> bool {
     match item.inner {
         ImplItem(_) => true,