---

yaml
---
r: 234861
b: refs/heads/stable
c: 0770f66
h: refs/heads/master
i:
  234859: 41e061b
v: v3

Author: GuillaumeGomez

[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: d5fdb55187ba319801b60f1d8e777cebbde71715
+refs/heads/stable: 0770f665d98c28507746d17c46289f1f9f250f31
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/configure

@@ -1037,14 +1037,6 @@ for target_file in ${CFG_SRC_DIR}mk/cfg/*.mk; do
   CFG_SUPPORTED_TARGET="${CFG_SUPPORTED_TARGET} $(basename "$target_file" .mk)"
 done
 
-# copy build-triples to host-triples so that builds are a subset of hosts
-V_TEMP=""
-for i in $CFG_BUILD $CFG_HOST;
-do
-   echo "$V_TEMP" | grep -qF $i || V_TEMP="$V_TEMP${V_TEMP:+ }$i"
-done
-CFG_HOST=$V_TEMP
-
 # copy host-triples to target-triples so that hosts are a subset of targets
 V_TEMP=""
 for i in $CFG_HOST $CFG_TARGET;

branches/stable/mk/main.mk

@@ -13,7 +13,7 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=1.3.0
+CFG_RELEASE_NUM=1.2.0
 
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release

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

@@ -101,8 +101,13 @@ we could have added more explanation in a new paragraph.
 
 #### Special sections
 
+```rust
+/// # Examples
+# fn foo() {}
+```
+
 Next, are special sections. These are indicated with a header, `#`. There
-are four kinds of headers that are commonly used. They aren't special syntax,
+are three kinds of headers that are commonly used. They aren't special syntax,
 just convention, for now.
 
 ```rust
@@ -144,7 +149,7 @@ responsible for upholding.
 # fn foo() {}
 ```
 
-Fourth, `Examples`. Include one or more examples of using your function or
+Third, `Examples`. Include one or more examples of using your function or
 method, and your users will love you for it. These examples go inside of
 code block annotations, which we'll talk about in a moment, and can have
 more than one section:

branches/stable/src/doc/trpl/installing-rust.md

@@ -41,8 +41,6 @@ $ sudo /usr/local/lib/rustlib/uninstall.sh
 If you used the Windows installer, just re-run the `.msi` and it will give you
 an uninstall option.
 
-## That disclaimer we promised
-
 Some people, and somewhat rightfully so, get very upset when we tell you to
 `curl | sh`. Basically, when you do this, you are trusting that the good
 people who maintain Rust aren't going to hack your computer and do bad things.
@@ -52,8 +50,6 @@ binary downloads][install-page].
 
 [from-source]: https://github.com/rust-lang/rust#building-from-source
 
-## Platform support
-
 Oh, we should also mention the officially supported platforms:
 
 * Windows (7, 8, Server 2008 R2)
@@ -70,8 +66,6 @@ integrated as the Linux/OS X experience is. We're working on it! If anything
 does not work, it is a bug. Please let us know if that happens. Each and every
 commit is tested against Windows just like any other platform.
 
-## After installation
-
 If you've got Rust installed, you can open up a shell, and type this:
 
 ```bash

branches/stable/src/liblibc/lib.rs

@@ -441,12 +441,12 @@ pub mod types {
                 pub type intmax_t = i64;
                 pub type uintmax_t = u64;
             }
-            #[cfg(any(target_arch = "mips",
+            #[cfg(any(target_arch = "x86",
+                      target_arch = "mips",
                       target_arch = "mipsel",
                       target_arch = "powerpc",
                       target_arch = "le32",
-                      all(any(target_arch = "arm", target_arch = "x86"),
-                          not(target_os = "android"))))]
+                      all(target_arch = "arm", not(target_os = "android"))))]
             pub mod posix88 {
                 pub type off_t = i32;
                 pub type dev_t = u64;
@@ -458,8 +458,7 @@ pub mod types {
                 pub type mode_t = u32;
                 pub type ssize_t = i32;
             }
-            #[cfg(all(any(target_arch = "arm", target_arch = "x86"),
-                      target_os = "android"))]
+            #[cfg(all(target_arch = "arm", target_os = "android"))]
             pub mod posix88 {
                 pub type off_t = i32;
                 pub type dev_t = u32;
@@ -474,8 +473,7 @@ pub mod types {
             #[cfg(any(target_arch = "x86",
                       target_arch = "le32",
                       target_arch = "powerpc",
-                      all(any(target_arch = "arm", target_arch = "x86"),
-                          not(target_os = "android"))))]
+                      all(target_arch = "arm", not(target_os = "android"))))]
             pub mod posix01 {
                 use types::os::arch::c95::{c_short, c_long, time_t};
                 use types::os::arch::posix88::{dev_t, gid_t, ino_t};
@@ -521,8 +519,7 @@ pub mod types {
                     pub __size: [u32; 9]
                 }
             }
-            #[cfg(all(any(target_arch = "arm", target_arch = "x86"),
-                          target_os = "android"))]
+            #[cfg(all(target_arch = "arm", target_os = "android"))]
             pub mod posix01 {
                 use types::os::arch::c95::{c_uchar, c_uint, c_ulong, time_t};
                 use types::os::arch::c99::{c_longlong, c_ulonglong};
@@ -5919,15 +5916,13 @@ pub mod funcs {
             use types::os::arch::c95::c_int;
             use types::os::common::posix01::sighandler_t;
 
-            #[cfg(not(all(target_os = "android", any(target_arch = "arm",
-                                                     target_arch = "x86"))))]
+            #[cfg(not(all(target_os = "android", target_arch = "arm")))]
             extern {
                 pub fn signal(signum: c_int,
                               handler: sighandler_t) -> sighandler_t;
             }
 
-            #[cfg(all(target_os = "android", any(target_arch = "arm",
-                                                 target_arch = "x86")))]
+            #[cfg(all(target_os = "android", target_arch = "arm"))]
             extern {
                 #[link_name = "bsd_signal"]
                 pub fn signal(signum: c_int,

branches/stable/src/librustc/middle/stability.rs

@@ -30,7 +30,6 @@ use syntax::feature_gate::emit_feature_err;
 use util::nodemap::{DefIdMap, FnvHashSet, FnvHashMap};
 
 use std::mem::replace;
-use std::cmp::Ordering;
 
 /// A stability index, giving the stability level for items and methods.
 pub struct Index<'tcx> {
@@ -60,57 +59,9 @@ impl<'a, 'tcx: 'a> Annotator<'a, 'tcx> {
         if self.index.staged_api[&ast::LOCAL_CRATE] {
             debug!("annotate(id = {:?}, attrs = {:?})", id, attrs);
             match attr::find_stability(self.tcx.sess.diagnostic(), attrs, item_sp) {
-                Some(mut stab) => {
+                Some(stab) => {
                     debug!("annotate: found {:?}", stab);
-                    // if parent is deprecated and we're not, inherit this by merging
-                    // deprecated_since and its reason.
-                    if let Some(parent_stab) = self.parent {
-                        if parent_stab.deprecated_since.is_some()
-                        && stab.deprecated_since.is_none() {
-                            stab.deprecated_since = parent_stab.deprecated_since.clone();
-                            stab.reason = parent_stab.reason.clone();
-                        }
-                    }
-
                     let stab = self.tcx.intern_stability(stab);
-
-                    // Check if deprecated_since < stable_since. If it is,
-                    // this is *almost surely* an accident.
-                    let deprecated_predates_stable = match (stab.deprecated_since.as_ref(),
-                                                            stab.since.as_ref()) {
-                        (Some(dep_since), Some(stab_since)) => {
-                            // explicit version of iter::order::lt to handle parse errors properly
-                            let mut is_less = false;
-                            for (dep_v, stab_v) in dep_since.split(".").zip(stab_since.split(".")) {
-                                match (dep_v.parse::<u64>(), stab_v.parse::<u64>()) {
-                                    (Ok(dep_v), Ok(stab_v)) => match dep_v.cmp(&stab_v) {
-                                        Ordering::Less => {
-                                            is_less = true;
-                                            break;
-                                        }
-                                        Ordering::Equal => { continue; }
-                                        Ordering::Greater => { break; }
-                                    },
-                                    _ => {
-                                        self.tcx.sess.span_err(item_sp,
-                                            "Invalid stability or deprecation version found");
-                                        // act like it isn't less because the question is now
-                                        // nonsensical, and this makes us not do anything else
-                                        // interesting.
-                                        break;
-                                    }
-                                }
-                            }
-                            is_less
-                        },
-                        _ => false,
-                    };
-
-                    if deprecated_predates_stable {
-                        self.tcx.sess.span_err(item_sp,
-                            "An API can't be stabilized after it is deprecated");
-                    }
-
                     self.index.map.insert(local_def(id), Some(stab));
 
                     // Don't inherit #[stable(feature = "rust1", since = "1.0.0")]

branches/stable/src/librustc_back/archive.rs

@@ -11,7 +11,6 @@
 //! A helper class for dealing with static archives
 
 use std::env;
-use std::ffi::OsString;
 use std::fs::{self, File};
 use std::io::prelude::*;
 use std::io;
@@ -31,8 +30,7 @@ pub struct ArchiveConfig<'a> {
     pub lib_search_paths: Vec<PathBuf>,
     pub slib_prefix: String,
     pub slib_suffix: String,
-    pub ar_prog: String,
-    pub command_path: OsString,
+    pub ar_prog: String
 }
 
 pub struct Archive<'a> {
@@ -116,7 +114,6 @@ impl<'a> Archive<'a> {
         let abs_dst = env::current_dir().unwrap().join(&self.config.dst);
         let ar = &self.config.ar_prog;
         let mut cmd = Command::new(ar);
-        cmd.env("PATH", &self.config.command_path);
         cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
         self.prepare_ar_action(&mut cmd, &abs_dst, action);
         info!("{:?}", cmd);

branches/stable/src/librustc_trans/back/link.rs

@@ -30,7 +30,6 @@ use util::fs::fix_windows_verbatim_for_gcc;
 use rustc_back::tempdir::TempDir;
 
 use std::env;
-use std::ffi::OsString;
 use std::fs::{self, PathExt};
 use std::io::{self, Read, Write};
 use std::mem;
@@ -371,17 +370,6 @@ pub fn get_ar_prog(sess: &Session) -> String {
     })
 }
 
-fn command_path(sess: &Session) -> OsString {
-    // The compiler's sysroot often has some bundled tools, so add it to the
-    // PATH for the child.
-    let mut new_path = sess.host_filesearch(PathKind::All)
-                           .get_tools_search_paths();
-    if let Some(path) = env::var_os("PATH") {
-        new_path.extend(env::split_paths(&path));
-    }
-    env::join_paths(new_path).unwrap()
-}
-
 pub fn remove(sess: &Session, path: &Path) {
     match fs::remove_file(path) {
         Ok(..) => {}
@@ -566,7 +554,6 @@ fn link_rlib<'a>(sess: &'a Session,
         slib_prefix: sess.target.target.options.staticlib_prefix.clone(),
         slib_suffix: sess.target.target.options.staticlib_suffix.clone(),
         ar_prog: get_ar_prog(sess),
-        command_path: command_path(sess),
     };
     let mut ab = ArchiveBuilder::create(config);
     ab.add_file(obj_filename).unwrap();
@@ -809,7 +796,15 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool,
     // The invocations of cc share some flags across platforms
     let pname = get_cc_prog(sess);
     let mut cmd = Command::new(&pname);
-    cmd.env("PATH", command_path(sess));
+
+    // The compiler's sysroot often has some bundled tools, so add it to the
+    // PATH for the child.
+    let mut new_path = sess.host_filesearch(PathKind::All)
+                           .get_tools_search_paths();
+    if let Some(path) = env::var_os("PATH") {
+        new_path.extend(env::split_paths(&path));
+    }
+    cmd.env("PATH", env::join_paths(new_path).unwrap());
 
     let root = sess.target_filesearch(PathKind::Native).get_lib_path();
     cmd.args(&sess.target.target.options.pre_link_args);
@@ -1192,7 +1187,6 @@ fn add_upstream_rust_crates(cmd: &mut Linker, sess: &Session,
                     slib_prefix: sess.target.target.options.staticlib_prefix.clone(),
                     slib_suffix: sess.target.target.options.staticlib_suffix.clone(),
                     ar_prog: get_ar_prog(sess),
-                    command_path: command_path(sess),
                 };
                 let mut archive = Archive::open(config);
                 archive.remove_file(&format!("{}.o", name));

branches/stable/src/librustc_typeck/diagnostics.rs

@@ -380,6 +380,19 @@ fn main() {
 ```
 "##,
 
+E0044: r##"
+You can't use type parameters on foreign items. Example of erroneous code:
+
+```
+extern { fn some_func<T>(); }
+```
+
+Just remove the type parameter to make this code works:
+
+```
+extern { fn some_func(); }
+```
+
 E0045: r##"
 Rust only supports variadic parameters for interoperability with C code in its
 FFI. As such, variadic parameters can only be used with functions which are
@@ -1488,7 +1501,9 @@ For more information see the [opt-in builtin traits RFC](https://github.com/rust
 }
 
 register_diagnostics! {
-    E0044, // foreign items may not have type parameters
+    E0034, // multiple applicable methods in scope
+    E0035, // does not take type parameters
+    E0036, // incorrect number of type parameters given for this method
     E0068,
     E0071,
     E0074,

branches/stable/src/libstd/sys/windows/os.rs

@@ -311,8 +311,6 @@ impl ExactSizeIterator for Args {
 
 impl Drop for Args {
     fn drop(&mut self) {
-        // self.cur can be null if CommandLineToArgvW previously failed,
-        // but LocalFree ignores NULL pointers
         unsafe { c::LocalFree(self.cur as *mut c_void); }
     }
 }
@@ -323,9 +321,6 @@ pub fn args() -> Args {
         let lpCmdLine = c::GetCommandLineW();
         let szArgList = c::CommandLineToArgvW(lpCmdLine, &mut nArgs);
 
-        // szArcList can be NULL if CommandLinToArgvW failed,
-        // but in that case nArgs is 0 so we won't actually
-        // try to read a null pointer
         Args { cur: szArgList, range: 0..(nArgs as isize) }
     }
 }

branches/stable/src/libstd/tuple.rs

@@ -25,9 +25,7 @@
 //! * `Eq`
 //! * `PartialOrd`
 //! * `Ord`
-//! * `Debug`
 //! * `Default`
-//! * `Hash`
 //!
 //! # Examples
 //!

branches/stable/src/libsyntax/attr.rs

@@ -397,7 +397,7 @@ fn find_stability_generic<'a,
                              -> (Option<Stability>, Vec<&'a AM>) {
 
     let mut stab: Option<Stability> = None;
-    let mut deprecated: Option<(Option<InternedString>, Option<InternedString>)> = None;
+    let mut deprecated: Option<(InternedString, Option<InternedString>)> = None;
     let mut used_attrs: Vec<&'a AM> = vec![];
 
     'outer: for attr in attrs {
@@ -484,7 +484,7 @@ fn find_stability_generic<'a,
                 diagnostic.span_err(item_sp, "multiple deprecated attributes");
             }
 
-            deprecated = Some((since, reason));
+            deprecated = Some((since.unwrap_or(intern_and_get_ident("bogus")), reason));
         }
     }
 
@@ -493,7 +493,7 @@ fn find_stability_generic<'a,
         match stab {
             Some(ref mut s) => {
                 let (since, reason) = deprecated.unwrap();
-                s.deprecated_since = since;
+                s.deprecated_since = Some(since);
                 s.reason = reason;
             }
             None => {