---

yaml
---
r: 235897
b: refs/heads/stable
c: 75e4a78
h: refs/heads/master
i:
  235895: d5ad904
v: v3

Author: bors

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: f6e9240a99e86d2c799dc29f179dd2870e51f71d
+refs/heads/stable: 75e4a78d15a837675eb6795b5afe4e1e3d27166c
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/doc/trpl/choosing-your-guarantees.md

@@ -81,7 +81,7 @@ The main guarantee provided here is that the data will not be destroyed until al
 are out of scope.
 
 This should be used when we wish to dynamically allocate and share some data (read-only) between
-various portions of yur program, where it is not certain which portion will finish using the pointer
+various portions of your program, where it is not certain which portion will finish using the pointer
 last. It's a viable alternative to `&T` when `&T` is either impossible to statically check for
 correctness, or creates extremely unergonomic code where the programmer does not wish to spend the
 development cost of working with.

branches/stable/src/doc/trpl/traits.md

@@ -347,40 +347,50 @@ easiest just to show an example:
 
 ```rust
 trait Foo {
-    fn bar(&self);
+    fn is_valid(&self) -> bool;
 
-    fn baz(&self) { println!("We called baz."); }
+    fn is_invalid(&self) -> bool { !self.is_valid() }
 }
 ```
 
-Implementors of the `Foo` trait need to implement `bar()`, but they don’t
-need to implement `baz()`. They’ll get this default behavior. They can
+Implementors of the `Foo` trait need to implement `is_valid()`, but they don’t
+need to implement `is_invalid()`. They’ll get this default behavior. They can
 override the default if they so choose:
 
 ```rust
 # trait Foo {
-# fn bar(&self);
-# fn baz(&self) { println!("We called baz."); }
+#     fn is_valid(&self) -> bool;
+#
+#     fn is_invalid(&self) -> bool { !self.is_valid() }
 # }
 struct UseDefault;
 
 impl Foo for UseDefault {
-    fn bar(&self) { println!("We called bar."); }
+    fn is_valid(&self) -> bool {
+        println!("Called UseDefault.is_valid.");
+        true
+    }
 }
 
 struct OverrideDefault;
 
 impl Foo for OverrideDefault {
-    fn bar(&self) { println!("We called bar."); }
+    fn is_valid(&self) -> bool {
+        println!("Called OverrideDefault.is_valid.");
+        true
+    }
 
-    fn baz(&self) { println!("Override baz!"); }
+    fn is_invalid(&self) -> bool {
+        println!("Called OverrideDefault.is_invalid!");
+        true // this implementation is a self-contradiction!
+    }
 }
 
 let default = UseDefault;
-default.baz(); // prints "We called baz."
+assert!(!default.is_invalid()); // prints "Called UseDefault.is_valid."
 
 let over = OverrideDefault;
-over.baz(); // prints "Override baz!"
+assert!(over.is_invalid()); // prints "Called OverrideDefault.is_invalid!"
 ```
 
 # Inheritance

branches/stable/src/libcore/result.rs

@@ -744,7 +744,7 @@ impl<T, E: fmt::Debug> Result<T, E> {
     /// x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
     /// ```
     #[inline]
-    #[unstable(feature = "result_expect", reason = "newly introduced")]
+    #[unstable(feature = "result_expect", reason = "newly introduced", issue = "27277")]
     pub fn expect(self, msg: &str) -> T {
         match self {
             Ok(t) => t,

branches/stable/src/librustc_lint/builtin.rs

@@ -436,6 +436,16 @@ fn is_repr_nullable_ptr<'tcx>(variants: &Vec<Rc<ty::VariantInfo<'tcx>>>) -> bool
     false
 }
 
+fn ast_ty_to_normalized<'tcx>(tcx: &ty::ctxt<'tcx>,
+                              id: ast::NodeId)
+                              -> Ty<'tcx> {
+    let tty = match tcx.ast_ty_to_ty_cache.borrow().get(&id) {
+        Some(&t) => t,
+        None => panic!("ast_ty_to_ty_cache was incomplete after typeck!")
+    };
+    infer::normalize_associated_type(tcx, &tty)
+}
+
 impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     /// Check if the given type is "ffi-safe" (has a stable, well-defined
     /// representation which can be exported to C code).
@@ -638,11 +648,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     }
 
     fn check_def(&mut self, sp: Span, id: ast::NodeId) {
-        let tty = match self.cx.tcx.ast_ty_to_ty_cache.borrow().get(&id) {
-            Some(&t) => t,
-            None => panic!("ast_ty_to_ty_cache was incomplete after typeck!")
-        };
-        let tty = infer::normalize_associated_type(self.cx.tcx, &tty);
+        let tty = ast_ty_to_normalized(self.cx.tcx, id);
 
         match ImproperCTypesVisitor::check_type_for_ffi(self, &mut FnvHashSet(), tty) {
             FfiResult::FfiSafe => {}
@@ -707,7 +713,10 @@ impl LintPass for ImproperCTypes {
                 check_ty(cx, &*input.ty);
             }
             if let ast::Return(ref ret_ty) = decl.output {
-                check_ty(cx, &**ret_ty);
+                let tty = ast_ty_to_normalized(cx.tcx, ret_ty.id);
+                if !tty.is_nil() {
+                    check_ty(cx, &ret_ty);
+                }
             }
         }
 

branches/stable/src/librustc_resolve/diagnostics.rs

@@ -397,6 +397,115 @@ impl Bar {
 ```
 "##,
 
+E0417: r##"
+A static variable was referenced in a pattern. Example of erroneous code:
+
+```
+static FOO : i32 = 0;
+
+match 0 {
+    FOO => {} // error: static variables cannot be referenced in a
+              //        pattern, use a `const` instead
+    _ => {}
+}
+```
+
+The compiler needs to know the value of the pattern at compile time;
+compile-time patterns can defined via const or enum items. Please verify
+that the identifier is spelled correctly, and if so, use a const instead
+of static to define it. Example:
+
+```
+const FOO : i32 = 0;
+
+match 0 {
+    FOO => {} // ok!
+    _ => {}
+}
+```
+"##,
+
+E0424: r##"
+The `self` keyword was used in a static method. Example of erroneous code:
+
+```
+struct Foo;
+
+impl Foo {
+    fn bar(self) {}
+
+    fn foo() {
+        self.bar(); // error: `self` is not available in a static method.
+    }
+}
+```
+
+Please check if the method's argument list should have contained `self`,
+`&self`, or `&mut self` (in case you didn't want to create a static
+method), and add it if so. Example:
+
+```
+struct Foo;
+
+impl Foo {
+    fn bar(self) {}
+
+    fn foo(self) {
+        self.bar(); // ok!
+    }
+}
+```
+"##,
+
+E0425: r##"
+An unresolved name was used. Example of erroneous codes:
+
+```
+something_that_doesnt_exist::foo;
+// error: unresolved name `something_that_doesnt_exist::foo`
+
+// or:
+trait Foo {
+    fn bar() {
+        Self; // error: unresolved name `Self`
+    }
+}
+```
+
+Please verify you didn't misspell the name or that you're not using an
+invalid object. Example:
+
+```
+enum something_that_does_exist {
+    foo
+}
+// or:
+mod something_that_does_exist {
+    pub static foo : i32 = 0i32;
+}
+
+something_that_does_exist::foo; // ok!
+```
+"##,
+
+E0426: r##"
+An undeclared label was used. Example of erroneous code:
+
+```
+loop {
+    break 'a; // error: use of undeclared label `'a`
+}
+```
+
+Please verify you spelt or declare the label correctly. Example:
+
+```
+'a: loop {
+    break 'a; // ok!
+}
+```
+"##,
+
 E0428: r##"
 A type or module has been defined more than once. Example of erroneous
 code:
@@ -415,6 +524,53 @@ struct Bar2; // ok!
 ```
 "##,
 
+E0430: r##"
+The `self` import appears more than once in the list. Erroneous code example:
+
+```
+use something::{self, self}; // error: `self` import can only appear once in
+                             //        the list
+```
+
+Please verify you didn't misspell the import name or remove the duplicated
+`self` import. Example:
+
+```
+use something::self; // ok!
+```
+"##,
+
+E0431: r##"
+`self` import was made. Erroneous code example:
+
+```
+use {self}; // error: `self` import can only appear in an import list with a
+            //        non-empty prefix
+```
+
+You cannot import the current module into itself, please remove this import
+or verify you didn't misspell it.
+"##,
+
+E0432: r##"
+An import was unresolved. Erroneous code example:
+
+```
+use something::Foo; // error: unresolved import `something::Foo`.
+```
+
+Please verify you didn't misspell the import name or the import does exist
+in the module from where you tried to import it. Example:
+
+```
+use something::Foo; // ok!
+
+mod something {
+    pub struct Foo;
+}
+```
+"##,
+
 E0433: r##"
 Invalid import. Example of erroneous code:
 
@@ -499,24 +655,15 @@ register_diagnostics! {
     E0414, // only irrefutable patterns allowed here
     E0415, // identifier is bound more than once in this parameter list
     E0416, // identifier is bound more than once in the same pattern
-    E0417, // static variables cannot be referenced in a pattern, use a
-           // `const` instead
     E0418, // is not an enum variant, struct or const
     E0419, // unresolved enum variant, struct or const
     E0420, // is not an associated const
     E0421, // unresolved associated const
     E0422, // does not name a structure
     E0423, // is a struct variant name, but this expression uses it like a
            // function name
-    E0424, // `self` is not available in a static method.
-    E0425, // unresolved name
-    E0426, // use of undeclared label
     E0427, // cannot use `ref` binding mode with ...
     E0429, // `self` imports are only allowed within a { } list
-    E0430, // `self` import can only appear once in the list
-    E0431, // `self` import can only appear in an import list with a non-empty
-           // prefix
-    E0432, // unresolved import
     E0434, // can't capture dynamic environment in a fn item
     E0435, // attempt to use a non-constant value in a constant
 }

branches/stable/src/librustc_trans/trans/base.rs

@@ -227,7 +227,6 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId,
     // FIXME(nagisa): perhaps the map of externs could be offloaded to llvm somehow?
     // FIXME(nagisa): investigate whether it can be changed into define_global
     let c = declare::declare_global(ccx, &name[..], ty);
-
     // Thread-local statics in some other crate need to *always* be linked
     // against in a thread-local fashion, so we need to be sure to apply the
     // thread-local attribute locally if it was present remotely. If we
@@ -239,42 +238,7 @@ pub fn get_extern_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, did: ast::DefId,
             llvm::set_thread_local(c, true);
         }
     }
-
-    // MSVC is a little ornery about how items are imported across dlls, and for
-    // lots more info on dllimport/dllexport see the large comment in
-    // SharedCrateContext::new. Unfortunately, unlike functions, statics
-    // imported from dlls *must* be tagged with dllimport (if you forget
-    // dllimport on a function then the linker fixes it up with an injected
-    // shim). This means that to link correctly to an upstream Rust dynamic
-    // library we need to make sure its statics are tagged with dllimport.
-    //
-    // Hence, if this translation is using dll storage attributes and the crate
-    // that this const originated from is being imported as a dylib at some
-    // point we tag this with dllimport.
-    //
-    // Note that this is not 100% correct for a variety of reasons:
-    //
-    // 1. If we are producing an rlib and linking to an upstream rlib, we'll
-    //    omit the dllimport. It's a possibility, though, that some later
-    //    downstream compilation will link the same upstream dependency as a
-    //    dylib and use our rlib, causing linker errors because we didn't use
-    //    dllimport.
-    // 2. We may have multiple crate output types. For example if we are
-    //    emitting a statically linked binary as well as a dynamic library we'll
-    //    want to omit dllimport for the binary but we need to have it for the
-    //    dylib.
-    //
-    // For most every day uses, however, this should suffice. During the
-    // bootstrap we're almost always linking upstream to a dylib for some crate
-    // type output, so most imports will be tagged with dllimport (somewhat
-    // appropriately). Otherwise rust dylibs linking against rust dylibs is
-    // pretty rare in Rust so this will likely always be `false` and we'll never
-    // tag with dllimport.
-    //
-    // Note that we can't just blindly tag all constants with dllimport as can
-    // cause linkage errors when we're not actually linking against a dll. For
-    // more info on this see rust-lang/rust#26591.
-    if ccx.use_dll_storage_attrs() && ccx.upstream_dylib_used(did.krate) {
+    if ccx.use_dll_storage_attrs() {
         llvm::SetDLLStorageClass(c, llvm::DLLImportStorageClass);
     }
     ccx.externs().borrow_mut().insert(name.to_string(), c);