---

yaml
---
r: 227699
b: refs/heads/try
c: 6bff14f
h: refs/heads/master
i:
  227697: 1c859cf
  227695: d4c08cf
v: v3

Author: Manishearth

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: a6cc4dd308213390a53a53101424ca4ef2e351ab
+refs/heads/try: 6bff14ffea5a3ca3f3b439b011954b521eb21a09
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/README.md

@@ -1,12 +1,14 @@
 # The Rust Programming Language
 
-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.
+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.
 
 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/try/src/libcore/ptr.rs

@@ -512,6 +512,11 @@ 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/try/src/librustc/lint/context.rs

@@ -28,9 +28,8 @@ 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, ReleaseChannel};
+use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid};
 use lint::builtin;
 use util::nodemap::FnvHashMap;
 
@@ -208,23 +207,6 @@ 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.
@@ -308,7 +290,6 @@ 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,
@@ -325,12 +306,6 @@ 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.
@@ -344,10 +319,6 @@ 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");
     }
@@ -689,9 +660,6 @@ 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/try/src/librustc/lint/mod.rs

@@ -247,9 +247,6 @@ 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/try/src/librustc/session/config.rs

@@ -32,6 +32,7 @@ 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;
@@ -119,21 +120,6 @@ 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,
@@ -1074,7 +1060,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::Default
+        (false, _, _) => UnstableFeatures::Allow
     }
 }
 

branches/try/src/librustc_driver/driver.rs

@@ -528,7 +528,8 @@ 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);
+                                              &krate, &attributes,
+                                              sess.opts.unstable_features);
         *sess.features.borrow_mut() = features;
         sess.abort_if_errors();
     });
@@ -558,7 +559,8 @@ 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);
+                                              &krate, &attributes,
+                                              sess.opts.unstable_features);
         *sess.features.borrow_mut() = features;
         sess.abort_if_errors();
     });
@@ -778,18 +780,11 @@ 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/try/src/librustc_driver/test.rs

@@ -35,6 +35,7 @@ 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>,
@@ -102,6 +103,7 @@ 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/try/src/librustc_lint/builtin.rs

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

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

@@ -29,6 +29,7 @@ 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;
@@ -794,7 +795,16 @@ 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[..]);
+    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 root = sess.target_filesearch(PathKind::Native).get_lib_path();
     cmd.args(&sess.target.target.options.pre_link_args);

branches/try/src/librustc_typeck/astconv.rs

@@ -290,10 +290,13 @@ pub fn ast_path_substs_for_ty<'tcx>(
         ast::AngleBracketedParameters(ref data) => {
             convert_angle_bracketed_parameters(this, rscope, span, decl_generics, data)
         }
-        ast::ParenthesizedParameters(ref data) => {
+        ast::ParenthesizedParameters(..) => {
             span_err!(tcx.sess, span, E0214,
-                "parenthesized parameters may only be used with a trait");
-            convert_parenthesized_parameters(this, rscope, span, decl_generics, data)
+                      "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![])
         }
     };
 

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

@@ -15,8 +15,11 @@ use CrateCtxt;
 
 use astconv::AstConv;
 use check::{self, FnCtxt};
-use middle::ty::{self, Ty};
+use middle::ty::{self, Ty, ToPolyTraitRef, AsPredicate};
 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};
@@ -59,12 +62,58 @@ 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, _), Some(_)) = (&rcvr_ty.sty, rcvr_expr) {
+            if let (&ty::TyStruct(did, substs), Some(expr)) = (&rcvr_ty.sty, rcvr_expr) {
                 let fields = ty::lookup_struct_fields(cx, did);
-                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));
+
+                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(),
+                        }
+                    }
                 }
             }
 

branches/try/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::Default,
+        unstable_features: UnstableFeatures::Allow,
         ..config::basic_options().clone()
     };
 

branches/try/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 `usize`, and the returned line is not
+    /// The expanded expression has type `u32`, 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 `usize`, and the returned column is not
+    /// The expanded expression has type `u32`, 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.
     ///