---

yaml
---
r: 172762
b: refs/heads/try
c: 2a29296
h: refs/heads/master
v: v3

Author: Nathan Stoddard

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 170c4399e614fe599c3d41306b3429ca8b3b68c6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 5b3cd3900ceda838f5798c30ab96ceb41f962534
-refs/heads/try: 507d9575bd266acbb084b0df78f23a774b0ba841
+refs/heads/try: 2a29296ea3f891f3216962d0ba8ada078a0657e6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/docs.mk

@@ -29,12 +29,6 @@ DOCS := index intro tutorial complement-bugreport \
     complement-lang-faq complement-design-faq complement-project-faq \
     rustdoc reference
 
-# Legacy guides, preserved for a while to reduce the number of 404s
-DOCS += guide-crates guide-error-handling guide-ffi guide-macros guide \
-    guide-ownership guide-plugins guide-pointers guide-strings guide-tasks \
-    guide-testing
-
-
 PDF_DOCS := reference
 
 RUSTDOC_DEPS_reference := doc/full-toc.inc
@@ -283,6 +277,6 @@ compiler-docs: $(COMPILER_DOC_TARGETS)
 
 trpl: doc/book/index.html
 
-doc/book/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/trpl/*.md) | doc/
+doc/book/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/trpl/*.md)
 	$(Q)rm -rf doc/book
 	$(Q)$(RUSTBOOK) build $(S)src/doc/trpl doc/book

branches/try/src/compiletest/header.rs

@@ -42,6 +42,8 @@ pub struct TestProps {
     pub pretty_compare_only: bool,
     // Patterns which must not appear in the output of a cfail test.
     pub forbid_output: Vec<String>,
+    // Ignore errors which originate from a command line span
+    pub ignore_command_line: bool,
 }
 
 // Load any test directives embedded in the file
@@ -60,6 +62,8 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pretty_mode = None;
     let mut pretty_compare_only = false;
     let mut forbid_output = Vec::new();
+    let mut ignore_command_line = false;
+
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -102,6 +106,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
             pretty_compare_only = parse_pretty_compare_only(ln);
         }
 
+        if !ignore_command_line {
+            ignore_command_line = parse_ignore_command_line(ln);
+        }
+
         match parse_aux_build(ln) {
             Some(ab) => { aux_builds.push(ab); }
             None => {}
@@ -140,6 +148,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
         pretty_compare_only: pretty_compare_only,
         forbid_output: forbid_output,
+        ignore_command_line: ignore_command_line,
     }
 }
 
@@ -291,6 +300,10 @@ fn parse_pretty_compare_only(line: &str) -> bool {
     parse_name_directive(line, "pretty-compare-only")
 }
 
+fn parse_ignore_command_line(line: &str) -> bool {
+    parse_name_directive(line, "ignore-command-line")
+}
+
 fn parse_exec_env(line: &str) -> Option<(String, String)> {
     parse_name_value_directive(line, "exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR

branches/try/src/compiletest/runtest.rs

@@ -104,7 +104,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         if !props.error_patterns.is_empty() {
             fatal("both error pattern and expected errors specified");
         }
-        check_expected_errors(expected_errors, testfile, &proc_res);
+        check_expected_errors(props, expected_errors, testfile, &proc_res);
     } else {
         check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
     }
@@ -941,7 +941,8 @@ fn check_forbid_output(props: &TestProps,
     }
 }
 
-fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
+fn check_expected_errors(props: &TestProps,
+                         expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {
 
@@ -996,6 +997,11 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
             was_expected = true;
         }
 
+        if line.starts_with("<command line option>") &&
+           props.ignore_command_line {
+            was_expected = true;
+        }
+
         if !was_expected && is_compiler_error_or_warning(line) {
             fatal_proc_rec(format!("unexpected compiler error or warning: '{}'",
                                   line).as_slice(),

branches/try/src/doc/guide-crates.md

@@ -11,7 +11,7 @@ navigate through the menu on the left.
 ## Basics
 
 This section is a linear introduction to the basic syntax and semantics of
-Rust. It has individual sections on each part of Rust's syntax, and cumulates
+Rust. It has individual sections on each part of Rust's syntax, and culminates
 in a small project: a guessing game.
 
 After reading "Basics," you will have a good foundation to learn more about

branches/try/src/doc/guide-error-handling.md

@@ -1,6 +1,6 @@
 % Advanced
 
-In a similar fashion to "Intermediate," this section is full of individual,
+In a similar fashion to "Intermediate," this setion is full of individual,
 deep-dive chapters, which stand alone and can be read in any order. These
 chapters focus on the most complex features, as well as some things that
 are only available in upcoming versions of Rust.

branches/try/src/doc/guide-ffi.md

@@ -1,7 +1,7 @@
 % Arrays, Vectors, and Slices
 
 Like many programming languages, Rust has list types to represent a sequence of
-things. The most basic is the *array*, a fixed-size list of elements of the
+things. The most basic is the **array**, a fixed-size list of elements of the
 same type. By default, arrays are immutable.
 
 ```{rust}
@@ -32,7 +32,7 @@ for e in a.iter() {
 }
 ```
 
-You can access a particular element of an array with *subscript notation*:
+You can access a particular element of an array with **subscript notation**:
 
 ```{rust}
 let names = ["Graydon", "Brian", "Niko"]; // names: [&str; 3]
@@ -47,7 +47,7 @@ array, you will get an error: array access is bounds-checked at run-time. Such
 errant access is the source of many bugs in other systems programming
 languages.
 
-A *vector* is a dynamic or "growable" array, implemented as the standard
+A **vector** is a dynamic or "growable" array, implemented as the standard
 library type [`Vec<T>`](../std/vec/) (we'll talk about what the `<T>` means
 later). Vectors are to arrays what `String` is to `&str`. You can create them
 with the `vec!` macro:
@@ -73,7 +73,7 @@ println!("The length of nums is now {}", nums.len());   // Prints 4
 
 Vectors have many more useful methods.
 
-A *slice* is a reference to (or "view" into) an array. They are useful for
+A **slice** is a reference to (or "view" into) an array. They are useful for
 allowing safe, efficient access to a portion of an array without copying. For
 example, you might want to reference just one line of a file read into memory.
 By nature, a slice is not created directly, but from an existing variable.

branches/try/src/doc/guide-macros.md

@@ -2,7 +2,7 @@
 
 So far, we've made lots of functions in Rust, but we've given them all names.
 Rust also allows us to create anonymous functions. Rust's anonymous
-functions are called *closures*. By themselves, closures aren't all that
+functions are called **closure**s. By themselves, closures aren't all that
 interesting, but when you combine them with functions that take closures as
 arguments, really powerful things are possible.
 
@@ -61,7 +61,7 @@ fn main() {
 
 ## Moving closures
 
-Rust has a second type of closure, called a *moving closure*. Moving
+Rust has a second type of closure, called a **moving closure**. Moving
 closures are indicated using the `move` keyword (e.g., `move || x *
 x`). The difference between a moving closure and an ordinary closure
 is that a moving closure always takes ownership of all variables that

branches/try/src/doc/guide-ownership.md

@@ -4,8 +4,8 @@ Now that we have some functions, it's a good idea to learn about comments.
 Comments are notes that you leave to other programmers to help explain things
 about your code. The compiler mostly ignores them.
 
-Rust has two kinds of comments that you should care about: *line comments*
-and *doc comments*.
+Rust has two kinds of comments that you should care about: **line comment**s
+and **doc comment**s.
 
 ```{rust}
 // Line comments are anything after '//' and extend to the end of the line.

branches/try/src/doc/guide-plugins.md

@@ -6,7 +6,7 @@ strings, but next, let's talk about some more complicated ways of storing data.
 
 ## Tuples
 
-The first compound data type we're going to talk about are called *tuples*.
+The first compound data type we're going to talk about are called **tuple**s.
 Tuples are an ordered list of a fixed size. Like this:
 
 ```rust
@@ -25,10 +25,10 @@ position having a type name rather than the value. Careful readers will also
 note that tuples are heterogeneous: we have an `i32` and a `&str` in this tuple.
 You haven't seen `&str` as a type before, and we'll discuss the details of
 strings later. In systems programming languages, strings are a bit more complex
-than in other languages. For now, just read `&str` as a *string slice*, and
+than in other languages. For now, just read `&str` as "a string slice," and
 we'll learn more soon.
 
-You can access the fields in a tuple through a *destructuring let*. Here's
+You can access the fields in a tuple through a **destructuring let**. Here's
 an example:
 
 ```rust
@@ -40,8 +40,8 @@ println!("x is {}", x);
 Remember before when I said the left-hand side of a `let` statement was more
 powerful than just assigning a binding? Here we are. We can put a pattern on
 the left-hand side of the `let`, and if it matches up to the right-hand side,
-we can assign multiple bindings at once. In this case, `let` "destructures,"
-or "breaks up," the tuple, and assigns the bits to three bindings.
+we can assign multiple bindings at once. In this case, `let` 'destructures,'
+or 'breaks up,' the tuple, and assigns the bits to three bindings.
 
 This pattern is very powerful, and we'll see it repeated more later.
 
@@ -83,18 +83,18 @@ fn main() {
 }
 ```
 
-Even though Rust functions can only return one value, a tuple *is* one value,
-that happens to be made up of more than one value. You can also see in this
-example how you can destructure a pattern returned by a function, as well.
+Even though Rust functions can only return one value, a tuple _is_ one value,
+that happens to be made up of more than one value. You can also see in this example how you
+can destructure a pattern returned by a function, as well.
 
 Tuples are a very simple data structure, and so are not often what you want.
 Let's move on to their bigger sibling, structs.
 
 ## Structs
 
-A struct is another form of a *record type*, just like a tuple. There's a
+A struct is another form of a 'record type,' just like a tuple. There's a
 difference: structs give each element that they contain a name, called a
-*field* or a *member*. Check it out:
+'field' or a 'member.' Check it out:
 
 ```rust
 struct Point {
@@ -143,7 +143,8 @@ This will print `The point is at (5, 0)`.
 ## Tuple Structs and Newtypes
 
 Rust has another data type that's like a hybrid between a tuple and a struct,
-called a *tuple struct*. Tuple structs do have a name, but their fields don't:
+called a **tuple struct**. Tuple structs do have a name, but their fields
+don't:
 
 
 ```{rust}
@@ -181,7 +182,7 @@ Now, we have actual names, rather than positions. Good names are important,
 and with a struct, we have actual names.
 
 There _is_ one case when a tuple struct is very useful, though, and that's a
-tuple struct with only one element. We call this a *newtype*, because it lets
+tuple struct with only one element. We call this a 'newtype,' because it lets
 you create a new type that's a synonym for another one:
 
 ```{rust}
@@ -198,7 +199,7 @@ destructuring `let`.
 
 ## Enums
 
-Finally, Rust has a "sum type", an *enum*. Enums are an incredibly useful
+Finally, Rust has a "sum type", an **enum**. Enums are an incredibly useful
 feature of Rust, and are used throughout the standard library. This is an enum
 that is provided by the Rust standard library:
 

branches/try/src/doc/guide-pointers.md

@@ -1,11 +1,10 @@
 % Conclusion
 
 We covered a lot of ground here. When you've mastered everything in this Guide,
-you will have a firm grasp of Rust development. There's a whole lot more
-out there, though, we've just covered the surface. There's tons of topics that
-you can dig deeper into, e.g. by reading the API documentation of the
-[standard library](http://doc.rust-lang.org/std/), by discovering solutions for
-common problems on [Rust by Example](http://rustbyexample.com/), or by browsing
-crates written by the community on [crates.io](https://crates.io/).
+you will have a firm grasp of basic Rust development. There's a whole lot more
+out there, we've just covered the surface. There's tons of topics that you can
+dig deeper into, and we've built specialized guides for many of them. To learn
+more, dig into the [full documentation
+index](index.html).
 
 Happy hacking!

branches/try/src/doc/guide-strings.md

@@ -8,17 +8,17 @@ these kinds of things, Rust has a module system.
 
 # Basic terminology: Crates and Modules
 
-Rust has two distinct terms that relate to the module system: *crate* and
-*module*. A crate is synonymous with a *library* or *package* in other
+Rust has two distinct terms that relate to the module system: "crate" and
+"module." A crate is synonymous with a 'library' or 'package' in other
 languages. Hence "Cargo" as the name of Rust's package management tool: you
 ship your crates to others with Cargo. Crates can produce an executable or a
 shared library, depending on the project.
 
-Each crate has an implicit *root module* that contains the code for that crate.
+Each crate has an implicit "root module" that contains the code for that crate.
 You can then define a tree of sub-modules under that root module. Modules allow
 you to partition your code within the crate itself.
 
-As an example, let's make a *phrases* crate, which will give us various phrases
+As an example, let's make a "phrases" crate, which will give us various phrases
 in different languages. To keep things simple, we'll stick to "greetings" and
 "farewells" as two kinds of phrases, and use English and Japanese (日本語） as
 two languages for those phrases to be in. We'll use this module layout:
@@ -45,7 +45,7 @@ two languages for those phrases to be in. We'll use this module layout:
 
 In this example, `phrases` is the name of our crate. All of the rest are
 modules.  You can see that they form a tree, branching out from the crate
-*root*, which is the root of the tree: `phrases` itself.
+"root", which is the root of the tree: `phrases` itself.
 
 Now that we have a plan, let's define these modules in code. To start,
 generate a new crate with Cargo: