---

yaml
---
r: 195375
b: refs/heads/snap-stage3
c: 6e8693b
h: refs/heads/master
i:
  195373: 17078c6
  195371: fa9c2a4
  195367: 214d7ee
  195359: 8e2d83f
v: v3

Author: richo

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 14192d6df5cc714e5c9a3ca70b08f2514d977be2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 470996a7499c2182eedecbed6d8d40026be3d566
+refs/heads/snap-stage3: 6e8693b297a841e8ada1828820136c850b793158
 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 identifiers below
+# Thad's Cygwin identifers below
 
 #   Vista 32 bit
     CYGWIN_NT-6.0)
@@ -526,8 +526,7 @@ VAL_OPTIONS=""
 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 opt helgrind 0 "run tests with helgrind instead of memcheck"
 opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind"
-opt docs     1 "build standard library documentation"
-opt compiler-docs     0 "build compiler documentation"
+opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"

branches/snap-stage3/mk/crates.mk

@@ -122,29 +122,17 @@ ONLY_RLIB_rustc_bitflags := 1
 # You should not need to edit below this line
 ################################################################################
 
-# On channels where the only usable crate is std, only build documentation for
-# std. This keeps distributions small and doesn't clutter up the API docs with
-# confusing internal details from the crates behind the facade.
-
-ifeq ($(CFG_RELEASE_CHANNEL),stable)
-DOC_CRATES := std
-else
-ifeq ($(CFG_RELEASE_CHANNEL),beta)
-DOC_CRATES := std
-else
 DOC_CRATES := $(filter-out rustc, \
-	   $(filter-out rustc_trans, \
-	   $(filter-out rustc_typeck, \
-	   $(filter-out rustc_borrowck, \
-	   $(filter-out rustc_resolve, \
-	   $(filter-out rustc_driver, \
-	   $(filter-out rustc_privacy, \
-	   $(filter-out rustc_lint, \
-	   $(filter-out log, \
-	   $(filter-out getopts, \
-	   $(filter-out syntax, $(CRATES))))))))))))
-endif
-endif
+              $(filter-out rustc_trans, \
+              $(filter-out rustc_typeck, \
+              $(filter-out rustc_borrowck, \
+              $(filter-out rustc_resolve, \
+              $(filter-out rustc_driver, \
+              $(filter-out rustc_privacy, \
+              $(filter-out rustc_lint, \
+              $(filter-out log, \
+              $(filter-out getopts, \
+              $(filter-out syntax, $(CRATES))))))))))))
 COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \
                        rustc_typeck rustc_driver syntax rustc_privacy \
                        rustc_lint

branches/snap-stage3/mk/docs.mk

@@ -259,10 +259,7 @@ doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1)) doc/$(1)/
 endef
 
 $(foreach crate,$(DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),DOC_TARGETS)))
-
-ifdef CFG_COMPILER_DOCS
-  $(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
-endif
+$(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
 
 ifdef CFG_DISABLE_DOCS
   $(info cfg: disabling doc build (CFG_DISABLE_DOCS))

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 everything
+  # On Bitrig, we need the relocation model to be PIC for everthing
   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
-# inadvertently included in the clean out.
+# inadvertantly 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/reference.md

@@ -1188,15 +1188,12 @@ the guarantee that these issues are never caused by safe code.
 
 * Data races
 * Dereferencing a null/dangling raw pointer
+* Mutating an immutable value/reference without `UnsafeCell`
 * Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values)
   (uninitialized) memory
 * Breaking the [pointer aliasing
   rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules)
   with raw pointers (a subset of the rules used by C)
-* `&mut` and `&` follow LLVM’s scoped [noalias] model, except if the `&T`
-  contains an `UnsafeCell<U>`. Unsafe code must not violate these aliasing
-  guarantees.
-* Mutating an immutable value/reference without `UnsafeCell<U>`
 * Invoking undefined behavior via compiler intrinsics:
   * Indexing outside of the bounds of an object with `std::ptr::offset`
     (`offset` intrinsic), with
@@ -1213,8 +1210,6 @@ the guarantee that these issues are never caused by safe code.
   code. Rust's failure system is not compatible with exception handling in
   other languages. Unwinding must be caught and handled at FFI boundaries.
 
-[noalias]: http://llvm.org/docs/LangRef.html#noalias
-
 ##### Behaviour not considered unsafe
 
 This is a list of behaviour not considered *unsafe* in Rust terms, but that may

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/arrays-vectors-and-slices.md

@@ -99,4 +99,5 @@ 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.
 
-We have now learned all of the most basic Rust concepts.
+We have now learned all of the most basic Rust concepts. Next, we learn how to
+get input from the keyboard.

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, because we don’t know the associated
+We can’t create a trait object like this, becuase 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 suppressed with `no_inline`:
+This behavior can be supressed with `no_inline`:
 
 ```ignore
 extern crate foo;

branches/snap-stage3/src/doc/trpl/method-syntax.md

@@ -50,9 +50,9 @@ parameter, of which there are three variants: `self`, `&self`, and `&mut self`.
 You can think of this first parameter as being the `x` in `x.foo()`. The three
 variants correspond to the three kinds of thing `x` could be: `self` if it's
 just a value on the stack, `&self` if it's a reference, and `&mut self` if it's
-a mutable reference. We should default to using `&self`, as you should prefer
-borrowing over taking ownership, as well as taking immutable references
-over mutable ones. Here's an example of all three variants:
+a mutable reference. We should default to using `&self`, as it's the most
+common, as Rustaceans prefer borrowing over taking ownership, and references 
+over mutable references. Here's an example of all three variants:
 
 ```rust
 struct Circle {

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

@@ -472,15 +472,10 @@ thread-safe counterpart of `Rc<T>`.
 
 ## Lifetime Elision
 
-Rust supports powerful local type inference in function bodies, but it’s
-forbidden in item signatures to allow reasoning about the types just based in
-the item signature alone. However, for ergonomic reasons a very restricted
-secondary inference algorithm called “lifetime elision” applies in function
-signatures. It infers only based on the signature components themselves and not
-based on the body of the function, only infers lifetime paramters, and does
-this with only three easily memorizable and unambiguous rules. This makes
-lifetime elision a shorthand for writing an item signature, while not hiding
-away the actual types involved as full local inference would if applied to it.
+Earlier, we mentioned *lifetime elision*, a feature of Rust which allows you to
+not write lifetime annotations in certain circumstances. All references have a
+lifetime, and so if you elide a lifetime (like `&T` instead of `&'a T`), Rust
+will do three things to determine what those lifetimes should be.
 
 When talking about lifetime elision, we use the term *input lifetime* and
 *output lifetime*. An *input lifetime* is a lifetime associated with a parameter

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 identifiers below
+# Thad's Cygwin identifers 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
-# version from the perspective of the server. Buildbot has typically finished
+# verison 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