---

yaml
---
r: 216816
b: refs/heads/stable
c: 978dc9f
h: refs/heads/master
v: v3

Author: robyoung

[refs]

@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: f23867aa66d61393183313f1828e6383d8365e47
+refs/heads/stable: 978dc9f36a7ebd5c16100ab6cf6ee5f528ccf14a
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

branches/stable/src/doc/trpl/error-handling.md

@@ -214,7 +214,7 @@ we can use the `unwrap()` method:
 io::stdin().read_line(&mut buffer).unwrap();
 ```
 
-`unwrap()` will `panic!` if the `Result` is `Err`. This basically says "Give
+`unwrap()` will `panic!` if the `Option` is `None`. This basically says "Give
 me the value, and if something goes wrong, just crash." This is less reliable
 than matching the error and attempting to recover, but is also significantly
 shorter. Sometimes, just crashing is appropriate.

branches/stable/src/doc/trpl/guessing-game.md

@@ -131,7 +131,9 @@ prints a [string][strings] to the screen.
     let mut guess = String::new();
 ```
 
-Now we’re getting interesting! There’s a lot going on in this little line. The first thing to notice is that this is a [let statement][let], which is used to create ‘variable bindings’. They take this form:
+Now we’re getting interesting! There’s a lot going on in this little line.
+The first thing to notice is that this is a [let statement][let], which is
+used to create ‘variable bindings’. They take this form:
 
 ```rust,ignore
 let foo = bar;
@@ -171,7 +173,7 @@ bound to: `String::new()`.
 
 [string]: ../std/string/struct.String.html
 
-The `::new()` syntax is uses `::` because this is an ‘associated function’ of
+The `::new()` syntax uses `::` because this is an ‘associated function’ of
 a particular type. That is to say, it’s associated with `String` itself,
 rather than a particular instance of a `String`. Some languages call this a
 ‘static method’.

branches/stable/src/librustc/diagnostics.rs

@@ -271,12 +271,6 @@ fn main() {
 See also http://doc.rust-lang.org/book/unsafe.html
 "##,
 
-E0137: r##"
-This error indicates that the compiler found multiple functions with the
-#[main] attribute. This is an error because there must be a unique entry point
-into a Rust program.
-"##,
-
 E0152: r##"
 Lang items are already implemented in the standard library. Unless you are
 writing a free-standing application (e.g. a kernel), you do not need to provide
@@ -425,142 +419,6 @@ of a loop. Without a loop to break out of or continue in, no sensible action can
 be taken.
 "##,
 
-E0271: r##"
-This is because of a type mismatch between the associated type of some
-trait (e.g. T::Bar, where T implements trait Quux { type Bar; })
-and another type U that is required to be equal to T::Bar, but is not.
-Examples follow.
-
-Here is a basic example:
-
-```
-trait Trait { type AssociatedType; }
-fn foo<T>(t: T) where T: Trait<AssociatedType=u32> {
-    println!("in foo");
-}
-impl Trait for i8 { type AssociatedType = &'static str; }
-foo(3_i8);
-```
-
-Here is that same example again, with some explanatory comments:
-
-```
-trait Trait { type AssociatedType; }
-
-fn foo<T>(t: T) where T: Trait<AssociatedType=u32> {
-//                    ~~~~~~~~ ~~~~~~~~~~~~~~~~~~
-//                        |            |
-//         This says `foo` can         |
-//           only be used with         |
-//              some type that         |
-//         implements `Trait`.         |
-//                                     |
-//                             This says not only must
-//                             `T` be an impl of `Trait`
-//                             but also that the impl
-//                             must assign the type `u32`
-//                             to the associated type.
-    println!("in foo");
-}
-
-impl Trait for i8 { type AssociatedType = &'static str; }
-~~~~~~~~~~~~~~~~~   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-//      |                             |
-// `i8` does have                     |
-// implementation                     |
-// of `Trait`...                      |
-//                     ... but it is an implementation
-//                     that assigns `&'static str` to
-//                     the associated type.
-
-foo(3_i8);
-// Here, we invoke `foo` with an `i8`, which does not satisfy
-// the constraint `<i8 as Trait>::AssociatedType=32`, and
-// therefore the type-checker complains with this error code.
-```
-
-Here is a more subtle instance of the same problem, that can
-arise with for-loops in Rust:
-
-```
-let vs: Vec<i32> = vec![1, 2, 3, 4];
-for v in &vs {
-    match v {
-        1 => {}
-        _ => {}
-    }
-}
-```
-
-The above fails because of an analogous type mismatch,
-though may be harder to see. Again, here are some
-explanatory comments for the same example:
-
-```
-{
-    let vs = vec![1, 2, 3, 4];
-
-    // `for`-loops use a protocol based on the `Iterator`
-    // trait. Each item yielded in a `for` loop has the
-    // type `Iterator::Item` -- that is,I `Item` is the
-    // associated type of the concrete iterator impl.
-    for v in &vs {
-//      ~    ~~~
-//      |     |
-//      |    We borrow `vs`, iterating over a sequence of
-//      |    *references* of type `&Elem` (where `Elem` is
-//      |    vector's element type). Thus, the associated
-//      |    type `Item` must be a reference `&`-type ...
-//      |
-//  ... and `v` has the type `Iterator::Item`, as dictated by
-//  the `for`-loop protocol ...
-
-        match v {
-            1 => {}
-//          ~
-//          |
-// ... but *here*, `v` is forced to have some integral type;
-// only types like `u8`,`i8`,`u16`,`i16`, et cetera can
-// match the pattern `1` ...
-
-            _ => {}
-        }
-
-// ... therefore, the compiler complains, because it sees
-// an attempt to solve the equations
-// `some integral-type` = type-of-`v`
-//                      = `Iterator::Item`
-//                      = `&Elem` (i.e. `some reference type`)
-//
-// which cannot possibly all be true.
-
-    }
-}
-```
-
-To avoid those issues, you have to make the types match correctly.
-So we can fix the previous examples like this:
-
-```
-// Basic Example:
-trait Trait { type AssociatedType; }
-fn foo<T>(t: T) where T: Trait<AssociatedType = &'static str> {
-    println!("in foo");
-}
-impl Trait for i8 { type AssociatedType = &'static str; }
-foo(3_i8);
-
-// For-Loop Example:
-let vs = vec![1, 2, 3, 4];
-for v in &vs {
-    match v {
-        &1 => {}
-        _ => {}
-    }
-}
-```
-"##,
-
 E0282: r##"
 This error indicates that type inference did not result in one unique possible
 type, and extra information is required. In most cases this can be provided
@@ -806,6 +664,7 @@ register_diagnostics! {
     E0134,
     E0135,
     E0136,
+    E0137,
     E0138,
     E0139,
     E0261, // use of undeclared lifetime name
@@ -815,6 +674,7 @@ register_diagnostics! {
     E0266, // expected item
     E0269, // not all control paths return a value
     E0270, // computation may converge in a function marked as diverging
+    E0271, // type mismatch resolving
     E0272, // rustc_on_unimplemented attribute refers to non-existent type parameter
     E0273, // rustc_on_unimplemented must have named format arguments
     E0274, // rustc_on_unimplemented must have a value

branches/stable/src/librustc_typeck/diagnostics.rs

@@ -34,18 +34,6 @@ let x_is_nonzero = x as bool;
 ```
 "##,
 
-E0062: r##"
-This error indicates that during an attempt to build a struct or struct-like
-enum variant, one of the fields was specified more than once. Each field should
-be specified exactly one time.
-"##,
-
-E0063: r##"
-This error indicates that during an attempt to build a struct or struct-like
-enum variant, one of the fields was not provided. Each field should be specified
-exactly once.
-"##,
-
 E0081: r##"
 Enum discriminants are used to differentiate enum variants stored in memory.
 This error indicates that the same value was used for two or more variants,
@@ -148,6 +136,8 @@ register_diagnostics! {
     E0059,
     E0060,
     E0061,
+    E0062,
+    E0063,
     E0066,
     E0067,
     E0068,

branches/stable/src/test/auxiliary/crateresolve3-1.rs

@@ -0,0 +1,15 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name="crateresolve3#0.1"]
+
+#![crate_type = "lib"]
+
+pub fn f() -> isize { 10 }

branches/stable/src/test/auxiliary/crateresolve3-2.rs

@@ -0,0 +1,15 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name="crateresolve3#0.2"]
+
+#![crate_type = "lib"]
+
+pub fn g() -> isize { 20 }

branches/stable/src/test/auxiliary/crateresolve5-1.rs

@@ -0,0 +1,34 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name="crateresolve5#0.1"]
+
+#![crate_type = "lib"]
+
+pub struct NameVal { pub name: String, pub val: isize }
+
+pub fn struct_nameval() -> NameVal {
+    NameVal { name: "crateresolve5".to_string(), val: 10 }
+}
+
+pub enum e {
+    e_val
+}
+
+pub fn nominal() -> e { e_val }
+
+pub fn nominal_eq(_e1: e, _e2: e) -> bool { true }
+
+impl PartialEq for e {
+    fn eq(&self, other: &e) -> bool { nominal_eq(*self, *other) }
+    fn ne(&self, other: &e) -> bool { !nominal_eq(*self, *other) }
+}
+
+pub fn f() -> isize { 10 }

branches/stable/src/test/auxiliary/crateresolve5-2.rs

@@ -0,0 +1,33 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name="crateresolve5#0.2"]
+
+#![crate_type = "lib"]
+
+pub struct NameVal { pub name: String, pub val: isize }
+pub fn struct_nameval() -> NameVal {
+    NameVal { name: "crateresolve5".to_string(), val: 10 }
+}
+
+pub enum e {
+    e_val
+}
+
+impl PartialEq for e {
+    fn eq(&self, other: &e) -> bool { !nominal_neq(*self, *other) }
+    fn ne(&self, other: &e) -> bool { nominal_neq(*self, *other) }
+}
+
+pub fn nominal() -> e { e_val }
+
+pub fn nominal_neq(_e1: e, _e2: e) -> bool { false }
+
+pub fn f() -> isize { 20 }

branches/stable/src/test/auxiliary/crateresolve7x.rs

@@ -0,0 +1,23 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// aux-build:crateresolve_calories-1.rs
+// aux-build:crateresolve_calories-2.rs
+
+// These both have the same version but differ in other metadata
+pub mod a {
+    extern crate cr_1 (name = "crateresolve_calories", vers = "0.1", calories="100");
+    pub fn f() -> isize { cr_1::f() }
+}
+
+pub mod b {
+    extern crate cr_2 (name = "crateresolve_calories", vers = "0.1", calories="200");
+    pub fn f() -> isize { cr_2::f() }
+}

branches/stable/src/test/auxiliary/crateresolve8-1.rs

@@ -0,0 +1,16 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// default link meta for 'package_id' will be equal to filestem
+#![crate_name="crateresolve8#0.1"]
+
+#![crate_type = "lib"]
+
+pub fn f() -> isize { 20 }

branches/stable/src/test/auxiliary/crateresolve_calories-1.rs

@@ -0,0 +1,14 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![crate_name="crateresolve_calories#0.1"]
+#![crate_type = "lib"]
+
+pub fn f() -> isize { 100 }