---

yaml
---
r: 226036
b: refs/heads/stable
c: a6cc4dd
h: refs/heads/master
v: v3

Author: Nick Hamann

[refs]

@@ -29,6 +29,6 @@ refs/heads/tmp: e5d90d98402475b6e154ce216f9efcb80da1a747
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 1fe32ca12c51afcd761d9962f51a74ff0d07a591
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: f50ae67ec2046e410ed070cff2f630a35dfe01ee
+refs/heads/stable: a6cc4dd308213390a53a53101424ca4ef2e351ab
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b

branches/stable/README.md

@@ -1,14 +1,12 @@
 # The Rust Programming Language
 
-Rust is a fast systems programming language that guarantees
-memory safety and offers painless concurrency ([no data races]).
-It does not employ a garbage collector and has minimal runtime overhead.
+Rust is a systems programming language that is fast, memory safe and
+multithreaded, but does not employ a garbage collector or otherwise
+impose significant runtime overhead.
 
 This repo contains the code for `rustc`, the Rust compiler, as well
 as standard libraries, tools and documentation for Rust.
 
-[no data races]: http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
-
 ## Quick Start
 
 Read ["Installing Rust"] from [The Book].

branches/stable/src/libcore/ptr.rs

@@ -512,11 +512,6 @@ impl<T: ?Sized> PartialOrd for *mut T {
 #[unstable(feature = "unique", reason = "needs an RFC to flesh out design")]
 pub struct Unique<T: ?Sized> {
     pointer: NonZero<*const T>,
-    // NOTE: this marker has no consequences for variance, but is necessary
-    // for dropck to understand that we logically own a `T`.
-    //
-    // For details, see:
-    // https://github.com/rust-lang/rfcs/blob/master/text/0769-sound-generic-drop.md#phantom-data
     _marker: PhantomData<T>,
 }
 

branches/stable/src/librustc/lint/context.rs

@@ -28,8 +28,9 @@ use self::TargetLint::*;
 use middle::privacy::ExportedItems;
 use middle::ty::{self, Ty};
 use session::{early_error, Session};
+use session::config::UnstableFeatures;
 use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass, LintPassObject};
-use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid};
+use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid, ReleaseChannel};
 use lint::builtin;
 use util::nodemap::FnvHashMap;
 
@@ -207,6 +208,23 @@ impl LintStore {
             }
         }
     }
+
+    fn maybe_stage_features(&mut self, sess: &Session) {
+        let lvl = match sess.opts.unstable_features {
+            UnstableFeatures::Default => return,
+            UnstableFeatures::Disallow => Forbid,
+            UnstableFeatures::Cheat => Allow
+        };
+        match self.by_name.get("unstable_features") {
+            Some(&Id(lint_id)) => if self.get_level_source(lint_id).0 != Forbid {
+                self.set_level(lint_id, (lvl, ReleaseChannel))
+            },
+            Some(&Renamed(_, lint_id)) => if self.get_level_source(lint_id).0 != Forbid {
+                self.set_level(lint_id, (lvl, ReleaseChannel))
+            },
+            None => unreachable!()
+        }
+    }
 }
 
 /// Context for lint checking.
@@ -290,6 +308,7 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
 
     let name = lint.name_lower();
     let mut def = None;
+    let mut note = None;
     let msg = match source {
         Default => {
             format!("{}, #[{}({})] on by default", msg,
@@ -306,6 +325,12 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
             def = Some(src);
             msg.to_string()
         }
+        ReleaseChannel => {
+            let release_channel = option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)");
+            note = Some(format!("this feature may not be used in the {} release channel",
+                                release_channel));
+            msg.to_string()
+        }
     };
 
     // For purposes of printing, we can treat forbid as deny.
@@ -319,6 +344,10 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
         _ => sess.bug("impossible level in raw_emit_lint"),
     }
 
+    if let Some(note) = note {
+        sess.note(&note[..]);
+    }
+
     if let Some(span) = def {
         sess.span_note(span, "lint level defined here");
     }
@@ -660,6 +689,9 @@ impl LintPass for GatherNodeLevels {
 pub fn check_crate(tcx: &ty::ctxt,
                    exported_items: &ExportedItems) {
 
+    // If this is a feature-staged build of rustc then flip several lints to 'forbid'
+    tcx.sess.lint_store.borrow_mut().maybe_stage_features(&tcx.sess);
+
     let krate = tcx.map.krate();
     let mut cx = Context::new(tcx, krate, exported_items);
 

branches/stable/src/librustc/lint/mod.rs

@@ -247,6 +247,9 @@ pub enum LintSource {
 
     /// Lint level was set by a command-line flag.
     CommandLine,
+
+    /// Lint level was set by the release channel.
+    ReleaseChannel
 }
 
 pub type LevelSource = (Level, LintSource);

branches/stable/src/librustc/session/config.rs

@@ -32,7 +32,6 @@ use syntax::attr::AttrMetaMethods;
 use syntax::diagnostic::{ColorConfig, Auto, Always, Never, SpanHandler};
 use syntax::parse;
 use syntax::parse::token::InternedString;
-use syntax::feature_gate::UnstableFeatures;
 
 use getopts;
 use std::collections::HashMap;
@@ -120,6 +119,21 @@ pub struct Options {
     pub unstable_features: UnstableFeatures
 }
 
+#[derive(Clone, Copy)]
+pub enum UnstableFeatures {
+    /// Hard errors for unstable features are active, as on
+    /// beta/stable channels.
+    Disallow,
+    /// Use the default lint levels
+    Default,
+    /// Errors are bypassed for bootstrapping. This is required any time
+    /// during the build that feature-related lints are set to warn or above
+    /// because the build turns on warnings-as-errors and uses lots of unstable
+    /// features. As a result, this this is always required for building Rust
+    /// itself.
+    Cheat
+}
+
 #[derive(Clone, PartialEq, Eq)]
 pub enum PrintRequest {
     FileNames,
@@ -1060,7 +1074,7 @@ pub fn get_unstable_features_setting() -> UnstableFeatures {
     match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) {
         (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat,
         (true, _, _) => UnstableFeatures::Disallow,
-        (false, _, _) => UnstableFeatures::Allow
+        (false, _, _) => UnstableFeatures::Default
     }
 }
 

branches/stable/src/librustc_driver/driver.rs

@@ -528,8 +528,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         let features =
             syntax::feature_gate::check_crate(sess.codemap(),
                                               &sess.parse_sess.span_diagnostic,
-                                              &krate, &attributes,
-                                              sess.opts.unstable_features);
+                                              &krate, &attributes);
         *sess.features.borrow_mut() = features;
         sess.abort_if_errors();
     });
@@ -559,8 +558,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         let features =
             syntax::feature_gate::check_crate(sess.codemap(),
                                               &sess.parse_sess.span_diagnostic,
-                                              &krate, &attributes,
-                                              sess.opts.unstable_features);
+                                              &krate, &attributes);
         *sess.features.borrow_mut() = features;
         sess.abort_if_errors();
     });
@@ -780,11 +778,18 @@ pub fn phase_5_run_llvm_passes(sess: &Session,
 pub fn phase_6_link_output(sess: &Session,
                            trans: &trans::CrateTranslation,
                            outputs: &OutputFilenames) {
+    let old_path = env::var_os("PATH").unwrap_or(OsString::new());
+    let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths();
+    new_path.extend(env::split_paths(&old_path));
+    env::set_var("PATH", &env::join_paths(&new_path).unwrap());
+
     time(sess.time_passes(), "linking", (), |_|
          link::link_binary(sess,
                            trans,
                            outputs,
                            &trans.link.crate_name));
+
+    env::set_var("PATH", &old_path);
 }
 
 fn escape_dep_filename(filename: &str) -> String {

branches/stable/src/librustc_driver/test.rs

@@ -35,7 +35,6 @@ use syntax::codemap;
 use syntax::codemap::{Span, CodeMap, DUMMY_SP};
 use syntax::diagnostic::{Level, RenderSpan, Bug, Fatal, Error, Warning, Note, Help};
 use syntax::parse::token;
-use syntax::feature_gate::UnstableFeatures;
 
 struct Env<'a, 'tcx: 'a> {
     infcx: &'a infer::InferCtxt<'a, 'tcx>,
@@ -103,7 +102,6 @@ fn test_env<F>(source_string: &str,
     let mut options =
         config::basic_options();
     options.debugging_opts.verbose = true;
-    options.unstable_features = UnstableFeatures::Allow;
     let codemap =
         CodeMap::new();
     let diagnostic_handler =

branches/stable/src/librustc_lint/builtin.rs

@@ -2213,7 +2213,7 @@ pub struct UnstableFeatures;
 declare_lint! {
     UNSTABLE_FEATURES,
     Allow,
-    "enabling unstable features (deprecated. do not use)"
+    "enabling unstable features"
 }
 
 impl LintPass for UnstableFeatures {

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

@@ -29,7 +29,6 @@ use util::sha2::{Digest, Sha256};
 use util::fs::fix_windows_verbatim_for_gcc;
 use rustc_back::tempdir::TempDir;
 
-use std::env;
 use std::fs::{self, PathExt};
 use std::io::{self, Read, Write};
 use std::mem;
@@ -795,16 +794,7 @@ 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);
-
-    // 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 mut cmd = Command::new(&pname[..]);
 
     let root = sess.target_filesearch(PathKind::Native).get_lib_path();
     cmd.args(&sess.target.target.options.pre_link_args);

branches/stable/src/librustc_typeck/astconv.rs

@@ -290,13 +290,10 @@ pub fn ast_path_substs_for_ty<'tcx>(
         ast::AngleBracketedParameters(ref data) => {
             convert_angle_bracketed_parameters(this, rscope, span, decl_generics, data)
         }
-        ast::ParenthesizedParameters(..) => {
+        ast::ParenthesizedParameters(ref data) => {
             span_err!(tcx.sess, span, E0214,
-                      "parenthesized parameters may only be used with a trait");
-            let ty_param_defs = decl_generics.types.get_slice(TypeSpace);
-            (Substs::empty(),
-             ty_param_defs.iter().map(|_| tcx.types.err).collect(),
-             vec![])
+                "parenthesized parameters may only be used with a trait");
+            convert_parenthesized_parameters(this, rscope, span, decl_generics, data)
         }
     };
 

branches/stable/src/librustc_typeck/check/method/suggest.rs

@@ -15,11 +15,8 @@ use CrateCtxt;
 
 use astconv::AstConv;
 use check::{self, FnCtxt};
-use middle::ty::{self, Ty, ToPolyTraitRef, AsPredicate};
+use middle::ty::{self, Ty};
 use middle::def;
-use middle::lang_items::FnOnceTraitLangItem;
-use middle::subst::Substs;
-use middle::traits::{Obligation, SelectionContext};
 use metadata::{csearch, cstore, decoder};
 
 use syntax::{ast, ast_util};
@@ -62,58 +59,12 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                 None);
 
             // If the item has the name of a field, give a help note
-            if let (&ty::TyStruct(did, substs), Some(expr)) = (&rcvr_ty.sty, rcvr_expr) {
+            if let (&ty::TyStruct(did, _), Some(_)) = (&rcvr_ty.sty, rcvr_expr) {
                 let fields = ty::lookup_struct_fields(cx, did);
-
-                if let Some(field) = fields.iter().find(|f| f.name == item_name) {
-                    let expr_string = match cx.sess.codemap().span_to_snippet(expr.span) {
-                        Ok(expr_string) => expr_string,
-                        _ => "s".into() // Default to a generic placeholder for the
-                                        // expression when we can't generate a string
-                                        // snippet
-                    };
-
-                    let span_stored_function = || {
-                        cx.sess.span_note(span,
-                                          &format!("use `({0}.{1})(...)` if you meant to call \
-                                                    the function stored in the `{1}` field",
-                                                   expr_string, item_name));
-                    };
-
-                    let span_did_you_mean = || {
-                        cx.sess.span_note(span, &format!("did you mean to write `{0}.{1}`?",
-                                                         expr_string, item_name));
-                    };
-
-                    // Determine if the field can be used as a function in some way
-                    let field_ty = ty::lookup_field_type(cx, did, field.id, substs);
-                    if let Ok(fn_once_trait_did) = cx.lang_items.require(FnOnceTraitLangItem) {
-                        let infcx = fcx.infcx();
-                        infcx.probe(|_| {
-                            let fn_once_substs = Substs::new_trait(vec![infcx.next_ty_var()],
-                                                                   Vec::new(),
-                                                                   field_ty);
-                            let trait_ref = ty::TraitRef::new(fn_once_trait_did,
-                                                              cx.mk_substs(fn_once_substs));
-                            let poly_trait_ref = trait_ref.to_poly_trait_ref();
-                            let obligation = Obligation::misc(span,
-                                                              fcx.body_id,
-                                                              poly_trait_ref.as_predicate());
-                            let mut selcx = SelectionContext::new(infcx, fcx);
-
-                            if selcx.evaluate_obligation(&obligation) {
-                                span_stored_function();
-                            } else {
-                                span_did_you_mean();
-                            }
-                        });
-                    } else {
-                        match field_ty.sty {
-                            // fallback to matching a closure or function pointer
-                            ty::TyClosure(..) | ty::TyBareFn(..) => span_stored_function(),
-                            _ => span_did_you_mean(),
-                        }
-                    }
+                if fields.iter().any(|f| f.name == item_name) {
+                    cx.sess.span_note(span,
+                        &format!("use `(s.{0})(...)` if you meant to call the \
+                                 function stored in the `{0}` field", item_name));
                 }
             }
 

branches/stable/src/librustdoc/core.rs

@@ -12,14 +12,14 @@ pub use self::MaybeTyped::*;
 use rustc_lint;
 use rustc_driver::driver;
 use rustc::session::{self, config};
+use rustc::session::config::UnstableFeatures;
 use rustc::middle::{privacy, ty};
 use rustc::ast_map;
 use rustc::lint;
 use rustc_trans::back::link;
 use rustc_resolve as resolve;
 
 use syntax::{ast, codemap, diagnostic};
-use syntax::feature_gate::UnstableFeatures;
 
 use std::cell::{RefCell, Cell};
 use std::collections::{HashMap, HashSet};
@@ -106,7 +106,7 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs,
         target_triple: triple.unwrap_or(config::host_triple().to_string()),
         cfg: config::parse_cfgspecs(cfgs),
         // Ensure that rustdoc works even if rustc is feature-staged
-        unstable_features: UnstableFeatures::Allow,
+        unstable_features: UnstableFeatures::Default,
         ..config::basic_options().clone()
     };
 

branches/stable/src/libstd/macros.rs

@@ -331,7 +331,7 @@ pub mod builtin {
 
     /// A macro which expands to the line number on which it was invoked.
     ///
-    /// The expanded expression has type `u32`, and the returned line is not
+    /// The expanded expression has type `usize`, and the returned line is not
     /// the invocation of the `line!()` macro itself, but rather the first macro
     /// invocation leading up to the invocation of the `line!()` macro.
     ///
@@ -346,7 +346,7 @@ pub mod builtin {
 
     /// A macro which expands to the column number on which it was invoked.
     ///
-    /// The expanded expression has type `u32`, and the returned column is not
+    /// The expanded expression has type `usize`, and the returned column is not
     /// the invocation of the `column!()` macro itself, but rather the first macro
     /// invocation leading up to the invocation of the `column!()` macro.
     ///