Rollup of 16 pull requests

Cargo.lock

@@ -36,6 +36,14 @@ dependencies = [
  "url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "annotate-snippets"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.11.0"
@@ -2246,7 +2254,7 @@ dependencies = [
  "rustc-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc-workspace-hack 1.0.0",
  "rustc_tools_util 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustfmt-nightly 1.2.0",
+ "rustfmt-nightly 1.2.1",
  "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_ignored 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -3038,8 +3046,9 @@ dependencies = [
 
 [[package]]
 name = "rustfmt-nightly"
-version = "1.2.0"
+version = "1.2.1"
 dependencies = [
+ "annotate-snippets 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
  "bytecount 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -3049,6 +3058,7 @@ dependencies = [
  "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "getopts 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ignore 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -3061,7 +3071,7 @@ dependencies = [
  "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
  "term 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "toml 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-segmentation 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode_categories 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -3987,6 +3997,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum adler32 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7e522997b529f05601e05166c07ed17789691f562762c7f3b987263d2dedee5c"
 "checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
 "checksum ammonia 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fd4c682378117e4186a492b2252b9537990e1617f44aed9788b9a1149de45477"
+"checksum annotate-snippets 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e8bcdcd5b291ce85a78f2b9d082a8de9676c12b1840d386d67bc5eea6f9d2b4e"
 "checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
 "checksum arc-swap 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1025aeae2b664ca0ea726a89d574fe8f4e77dd712d443236ad1de00379450cf6"
 "checksum argon2rs 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "3f67b0b6a86dae6e67ff4ca2b6201396074996379fba2b92ff649126f37cb392"

src/bootstrap/test.rs

@@ -1268,11 +1268,11 @@ impl Step for Compiletest {
  builder.add_rust_test_threads(&mut cmd);
 
  if builder.config.sanitizers {
- cmd.env("SANITIZER_SUPPORT", "1");
+ cmd.env("RUSTC_SANITIZER_SUPPORT", "1");
  }
 
  if builder.config.profiler {
- cmd.env("PROFILER_SUPPORT", "1");
+ cmd.env("RUSTC_PROFILER_SUPPORT", "1");
  }
 
  cmd.env("RUST_TEST_TMPDIR", builder.out.join("tmp"));

src/liballoc/fmt.rs

@@ -343,9 +343,10 @@
 //! * `^` - the argument is center-aligned in `width` columns
 //! * `>` - the argument is right-aligned in `width` columns
 //!
-//! Note that alignment may not be implemented by some types. A good way
-//! to ensure padding is applied is to format your input, then use this
-//! resulting string to pad your output.
+//! Note that alignment may not be implemented by some types. In particular, it
+//! is not generally implemented for the `Debug` trait. A good way to ensure
+//! padding is applied is to format your input, then use this resulting string
+//! to pad your output.
 //!
 //! ## Sign/`#`/`0`
 //!

src/libcore/iter/adapters/mod.rs

@@ -981,6 +981,16 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
  })
  }
 
+ #[inline]
+ fn nth_back(&mut self, n: usize) -> Option<(usize, <I as Iterator>::Item)> {
+ self.iter.nth_back(n).map(|a| {
+ let len = self.iter.len();
+ // Can safely add, `ExactSizeIterator` promises that the number of
+ // elements fits into a `usize`.
+ (self.count + len, a)
+ })
+ }
+
  #[inline]
  fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where
  Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
@@ -1790,6 +1800,17 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
  }
  }
 
+ #[inline]
+ default fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item> {
+ if self.done {
+ None
+ } else {
+ let nth = self.iter.nth_back(n);
+ self.done = nth.is_none();
+ nth
+ }
+ }
+
  #[inline]
  default fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
  Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>
@@ -1878,6 +1899,11 @@ impl<I> DoubleEndedIterator for Fuse<I>
  self.iter.next_back()
  }
 
+ #[inline]
+ fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item> {
+ self.iter.nth_back(n)
+ }
+
  #[inline]
  fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
  Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>

src/libcore/slice/mod.rs

@@ -838,7 +838,7 @@ impl<T> [T] {
  }
 
  /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the
- /// beginning of the slice.
+ /// end of the slice.
  ///
  /// The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the
  /// slice, then the last up to `chunk_size-1` elements will be omitted and can be retrieved
@@ -849,7 +849,7 @@ impl<T> [T] {
  ///
  /// See [`rchunks`] for a variant of this iterator that also returns the remainder as a smaller
  /// chunk, and [`chunks_exact`] for the same iterator but starting at the beginning of the
- /// slice of the slice.
+ /// slice.
  ///
  /// # Panics
  ///
@@ -890,7 +890,7 @@ impl<T> [T] {
  ///
  /// See [`rchunks_mut`] for a variant of this iterator that also returns the remainder as a
  /// smaller chunk, and [`chunks_exact_mut`] for the same iterator but starting at the beginning
- /// of the slice of the slice.
+ /// of the slice.
  ///
  /// # Panics
  ///

src/libcore/str/mod.rs

@@ -795,6 +795,11 @@ impl DoubleEndedIterator for Bytes<'_> {
  self.0.next_back()
  }
 
+ #[inline]
+ fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+ self.0.nth_back(n)
+ }
+
  #[inline]
  fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
  P: FnMut(&Self::Item) -> bool

src/libcore/tests/iter.rs

@@ -389,6 +389,24 @@ fn test_iterator_enumerate_nth() {
  assert_eq!(i, 3);
 }
 
+#[test]
+fn test_iterator_enumerate_nth_back() {
+ let xs = [0, 1, 2, 3, 4, 5];
+ let mut it = xs.iter().enumerate();
+ while let Some((i, &x)) = it.nth_back(0) {
+ assert_eq!(i, x);
+ }
+
+ let mut it = xs.iter().enumerate();
+ while let Some((i, &x)) = it.nth_back(1) {
+ assert_eq!(i, x);
+ }
+
+ let (i, &x) = xs.iter().enumerate().nth_back(3).unwrap();
+ assert_eq!(i, x);
+ assert_eq!(i, 2);
+}
+
 #[test]
 fn test_iterator_enumerate_count() {
  let xs = [0, 1, 2, 3, 4, 5];

src/librustc/hir/intravisit.rs

@@ -57,6 +57,14 @@ impl<'a> FnKind<'a> {
  FnKind::Closure(attrs) => attrs,
  }
  }
+
+ pub fn header(&self) -> Option<FnHeader> {
+ match *self {
+ FnKind::ItemFn(_, _, header, _, _) => Some(header),
+ FnKind::Method(_, sig, _, _) => Some(sig.header),
+ FnKind::Closure(_) => None,
+ }
+ }
 }
 
 /// Specifies what nested things a visitor wants to visit. The most

src/librustc/hir/lowering.rs

@@ -4685,6 +4685,14 @@ impl<'a> LoweringContext<'a> {
  Symbol::intern("try_trait")
  ].into()),
  );
+ let try_span = self.sess.source_map().end_point(e.span);
+ let try_span = self.mark_span_with_reason(
+ CompilerDesugaringKind::QuestionMark,
+ try_span,
+ Some(vec![
+ Symbol::intern("try_trait")
+ ].into()),
+ );
 
  // `Try::into_result(<expr>)`
  let discr = {
@@ -4729,14 +4737,14 @@ impl<'a> LoweringContext<'a> {
  // return Try::from_error(From::from(err)),`
  let err_arm = {
  let err_ident = self.str_to_ident("err");
- let (err_local, err_local_nid) = self.pat_ident(e.span, err_ident);
+ let (err_local, err_local_nid) = self.pat_ident(try_span, err_ident);
  let from_expr = {
  let path = &["convert", "From", "from"];
  let from = P(self.expr_std_path(
- e.span, path, None, ThinVec::new()));
- let err_expr = self.expr_ident(e.span, err_ident, err_local_nid);
+ try_span, path, None, ThinVec::new()));
+ let err_expr = self.expr_ident(try_span, err_ident, err_local_nid);
 
- self.expr_call(e.span, from, hir_vec![err_expr])
+ self.expr_call(try_span, from, hir_vec![err_expr])
  };
  let from_err_expr =
  self.wrap_in_try_constructor("from_error", from_expr, unstable_span);
@@ -4745,7 +4753,7 @@ impl<'a> LoweringContext<'a> {
  let ret_expr = if let Some(catch_node) = catch_scope {
  let target_id = Ok(self.lower_node_id(catch_node).hir_id);
  P(self.expr(
- e.span,
+ try_span,
  hir::ExprKind::Break(
  hir::Destination {
  label: None,
@@ -4756,10 +4764,10 @@ impl<'a> LoweringContext<'a> {
  thin_attrs,
  ))
  } else {
- P(self.expr(e.span, hir::ExprKind::Ret(Some(from_err_expr)), thin_attrs))
+ P(self.expr(try_span, hir::ExprKind::Ret(Some(from_err_expr)), thin_attrs))
  };
 
- let err_pat = self.pat_err(e.span, err_local);
+ let err_pat = self.pat_err(try_span, err_local);
  self.arm(hir_vec![err_pat], ret_expr)
  };
 

src/librustc/hir/map/blocks.rs

@@ -175,27 +175,15 @@ impl<'a> FnLikeNode<'a> {
  }
 
  pub fn constness(self) -> ast::Constness {
- match self.kind() {
- FnKind::ItemFn(_, _, header, ..) => header.constness,
- FnKind::Method(_, m, ..) => m.header.constness,
- _ => ast::Constness::NotConst
- }
+ self.kind().header().map_or(ast::Constness::NotConst, |header| header.constness)
  }
 
  pub fn asyncness(self) -> ast::IsAsync {
- match self.kind() {
- FnKind::ItemFn(_, _, header, ..) => header.asyncness,
- FnKind::Method(_, m, ..) => m.header.asyncness,
- _ => ast::IsAsync::NotAsync
- }
+ self.kind().header().map_or(ast::IsAsync::NotAsync, |header| header.asyncness)
  }
 
  pub fn unsafety(self) -> ast::Unsafety {
- match self.kind() {
- FnKind::ItemFn(_, _, header, ..) => header.unsafety,
- FnKind::Method(_, m, ..) => m.header.unsafety,
- _ => ast::Unsafety::Normal
- }
+ self.kind().header().map_or(ast::Unsafety::Normal, |header| header.unsafety)
  }
 
  pub fn kind(self) -> FnKind<'a> {

src/librustc/session/mod.rs

@@ -165,6 +165,10 @@ pub struct Session {
 
  /// `Span`s of trait methods that weren't found to avoid emitting object safety errors
  pub trait_methods_not_found: Lock<FxHashSet<Span>>,
+
+ /// Mapping from ident span to path span for paths that don't exist as written, but that
+ /// exist under `std`. For example, wrote `str::from_utf8` instead of `std::str::from_utf8`.
+ pub confused_type_with_std_module: Lock<FxHashMap<Span, Span>>,
 }
 
 pub struct PerfStats {
@@ -1248,6 +1252,7 @@ fn build_session_(
  has_panic_handler: Once::new(),
  driver_lint_caps,
  trait_methods_not_found: Lock::new(Default::default()),
+ confused_type_with_std_module: Lock::new(Default::default()),
  };
 
  validate_commandline_args_with_session_available(&sess);

src/librustc/traits/error_reporting.rs

@@ -638,6 +638,18 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
  let OnUnimplementedNote { message, label, note }
  = self.on_unimplemented_note(trait_ref, obligation);
  let have_alt_message = message.is_some() || label.is_some();
+ let is_try = self.tcx.sess.source_map().span_to_snippet(span)
+ .map(|s| &s == "?")
+ .unwrap_or(false);
+ let is_from = format!("{}", trait_ref).starts_with("std::convert::From<");
+ let message = if is_try && is_from {
+ Some(format!(
+ "`?` couldn't convert the error to `{}`",
+ trait_ref.self_ty(),
+ ))
+ } else {
+ message
+ };
 
  let mut err = struct_span_err!(
  self.tcx.sess,

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -1382,7 +1382,6 @@ extern "C" {
  pub fn LLVMRustDebugMetadataVersion() -> u32;
  pub fn LLVMRustVersionMajor() -> u32;
  pub fn LLVMRustVersionMinor() -> u32;
- pub fn LLVMRustIsRustLLVM() -> bool;
 
  pub fn LLVMRustAddModuleFlag(M: &Module, name: *const c_char, value: u32);
 

src/librustc_codegen_llvm/llvm_util.rs

@@ -61,7 +61,7 @@ unsafe fn configure_llvm(sess: &Session) {
  if sess.opts.debugging_opts.disable_instrumentation_preinliner {
  add("-disable-preinline");
  }
- if llvm::LLVMRustIsRustLLVM() {
+ if get_major_version() >= 8 {
  match sess.opts.debugging_opts.merge_functions
  .unwrap_or(sess.target.target.options.merge_functions) {
  MergeFunctions::Disabled |
@@ -154,6 +154,7 @@ const X86_WHITELIST: &[(&str, Option<&str>)] = &[
  ("popcnt", None),
  ("rdrand", None),
  ("rdseed", None),
+ ("rtm", Some("rtm_target_feature")),
  ("sha", None),
  ("sse", None),
  ("sse2", None),

src/librustc_resolve/diagnostics.rs

@@ -166,16 +166,18 @@ impl<'a> Resolver<'a> {
  let self_is_available = self.self_value_is_available(path[0].ident.span, span);
  match candidate {
  AssocSuggestion::Field => {
- err.span_suggestion(
- span,
- "try",
- format!("self.{}", path_str),
- Applicability::MachineApplicable,
- );
- if !self_is_available {
- err.span_label(span, format!("`self` value is a keyword \
- only available in \
- methods with `self` parameter"));
+ if self_is_available {
+ err.span_suggestion(
+ span,
+ "you might have meant to use the available field",
+ format!("self.{}", path_str),
+ Applicability::MachineApplicable,
+ );
+ } else {
+ err.span_label(
+ span,
+ "a field by this name exists in `Self`",
+ );
  }
  }
  AssocSuggestion::MethodWithSelf if self_is_available => {