Rollup of 8 pull requests

src/bootstrap/bootstrap.py

@@ -314,7 +314,6 @@ def __init__(self):
  self.build_dir = os.path.join(os.getcwd(), "build")
  self.clean = False
  self.config_toml = ''
- self.printed = False
  self.rust_root = os.path.abspath(os.path.join(__file__, '../../..'))
  self.use_locked_deps = ''
  self.use_vendored_sources = ''
@@ -336,7 +335,6 @@ def download_stage0(self):
  if self.rustc().startswith(self.bin_root()) and \
  (not os.path.exists(self.rustc()) or
  self.program_out_of_date(self.rustc_stamp())):
- self.print_what_bootstrap_means()
  if os.path.exists(self.bin_root()):
  shutil.rmtree(self.bin_root())
  filename = "rust-std-{}-{}.tar.gz".format(
@@ -354,7 +352,6 @@ def download_stage0(self):
  if self.cargo().startswith(self.bin_root()) and \
  (not os.path.exists(self.cargo()) or
  self.program_out_of_date(self.cargo_stamp())):
- self.print_what_bootstrap_means()
  filename = "cargo-{}-{}.tar.gz".format(cargo_channel, self.build)
  self._download_stage0_helper(filename, "cargo")
  self.fix_executable("{}/bin/cargo".format(self.bin_root()))
@@ -555,23 +552,6 @@ def exe_suffix():
  return '.exe'
  return ''
 
- def print_what_bootstrap_means(self):
- """Prints more information about the build system"""
- if hasattr(self, 'printed'):
- return
- self.printed = True
- if os.path.exists(self.bootstrap_binary()):
- return
- if '--help' not in sys.argv or len(sys.argv) == 1:
- return
-
- print('info: the build system for Rust is written in Rust, so this')
- print(' script is now going to download a stage0 rust compiler')
- print(' and then compile the build system itself')
- print('')
- print('info: in the meantime you can read more about rustbuild at')
- print(' src/bootstrap/README.md before the download finishes')
-
  def bootstrap_binary(self):
  """Return the path of the boostrap binary
 
@@ -585,7 +565,6 @@ def bootstrap_binary(self):
 
  def build_bootstrap(self):
  """Build bootstrap"""
- self.print_what_bootstrap_means()
  build_dir = os.path.join(self.build_dir, "bootstrap")
  if self.clean and os.path.exists(build_dir):
  shutil.rmtree(build_dir)
@@ -670,8 +649,16 @@ def set_dev_environment(self):
  self._download_url = 'https://dev-static.rust-lang.org'
 
 
-def bootstrap():
+def bootstrap(help_triggered):
  """Configure, fetch, build and run the initial bootstrap"""
+
+ # If the user is asking for help, let them know that the whole download-and-build
+ # process has to happen before anything is printed out.
+ if help_triggered:
+ print("info: Downloading and building bootstrap before processing --help")
+ print(" command. See src/bootstrap/README.md for help with common")
+ print(" commands.")
+
  parser = argparse.ArgumentParser(description='Build rust')
  parser.add_argument('--config')
  parser.add_argument('--build')
@@ -708,7 +695,7 @@ def bootstrap():
  print(' and so in order to preserve your $HOME this will now')
  print(' use vendored sources by default. Note that if this')
  print(' does not work you should run a normal build first')
- print(' before running a command like `sudo make install`')
+ print(' before running a command like `sudo ./x.py install`')
 
  if build.use_vendored_sources:
  if not os.path.exists('.cargo'):
@@ -734,7 +721,10 @@ def bootstrap():
  if 'dev' in data:
  build.set_dev_environment()
 
- build.update_submodules()
+ # No help text depends on submodules. This check saves ~1 minute of git commands, even if
+ # all the submodules are present and downloaded!
+ if not help_triggered:
+ build.update_submodules()
 
  # Fetch/build the bootstrap
  build.build = args.build or build.build_triple()
@@ -760,7 +750,7 @@ def main():
  help_triggered = (
  '-h' in sys.argv) or ('--help' in sys.argv) or (len(sys.argv) == 1)
  try:
- bootstrap()
+ bootstrap(help_triggered)
  if not help_triggered:
  print("Build completed successfully in {}".format(
  format_build_time(time() - start_time)))

src/bootstrap/doc.rs

@@ -312,6 +312,7 @@ fn invoke_rustdoc(builder: &Builder, compiler: Compiler, target: Interned<String
  cmd.arg("--html-after-content").arg(&footer)
  .arg("--html-before-content").arg(&version_info)
  .arg("--html-in-header").arg(&favicon)
+ .arg("--markdown-no-toc")
  .arg("--markdown-playground-url")
  .arg("https://play.rust-lang.org/")
  .arg("-o").arg(&out)

src/libcore/benches/iter.rs

@@ -281,3 +281,32 @@ bench_sums! {
  bench_take_while_chain_ref_sum,
  (0i64..1000000).chain(1000000..).take_while(|&x| x < 1111111)
 }
+
+// Checks whether Skip<Zip<A,B>> is as fast as Zip<Skip<A>, Skip<B>>, from
+// https://users.rust-lang.org/t/performance-difference-between-iterator-zip-and-skip-order/15743
+#[bench]
+fn bench_zip_then_skip(b: &mut Bencher) {
+ let v: Vec<_> = (0..100_000).collect();
+ let t: Vec<_> = (0..100_000).collect();
+
+ b.iter(|| {
+ let s = v.iter().zip(t.iter()).skip(10000)
+ .take_while(|t| *t.0 < 10100)
+ .map(|(a, b)| *a + *b)
+ .sum::<u64>();
+ assert_eq!(s, 2009900);
+ });
+}
+#[bench]
+fn bench_skip_then_zip(b: &mut Bencher) {
+ let v: Vec<_> = (0..100_000).collect();
+ let t: Vec<_> = (0..100_000).collect();
+
+ b.iter(|| {
+ let s = v.iter().skip(10000).zip(t.iter().skip(10000))
+ .take_while(|t| *t.0 < 10100)
+ .map(|(a, b)| *a + *b)
+ .sum::<u64>();
+ assert_eq!(s, 2009900);
+ });
+}

src/libcore/iter/mod.rs

@@ -1045,6 +1045,11 @@ impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator
  fn size_hint(&self) -> (usize, Option<usize>) {
  ZipImpl::size_hint(self)
  }
+
+ #[inline]
+ fn nth(&mut self, n: usize) -> Option<Self::Item> {
+ ZipImpl::nth(self, n)
+ }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1065,6 +1070,14 @@ trait ZipImpl<A, B> {
  fn new(a: A, b: B) -> Self;
  fn next(&mut self) -> Option<Self::Item>;
  fn size_hint(&self) -> (usize, Option<usize>);
+ fn nth(&mut self, n: usize) -> Option<Self::Item>;
+ fn super_nth(&mut self, mut n: usize) -> Option<Self::Item> {
+ while let Some(x) = self.next() {
+ if n == 0 { return Some(x) }
+ n -= 1;
+ }
+ None
+ }
  fn next_back(&mut self) -> Option<Self::Item>
  where A: DoubleEndedIterator + ExactSizeIterator,
  B: DoubleEndedIterator + ExactSizeIterator;
@@ -1094,6 +1107,11 @@ impl<A, B> ZipImpl<A, B> for Zip<A, B>
  })
  }
 
+ #[inline]
+ default fn nth(&mut self, n: usize) -> Option<Self::Item> {
+ self.super_nth(n)
+ }
+
  #[inline]
  default fn next_back(&mut self) -> Option<(A::Item, B::Item)>
  where A: DoubleEndedIterator + ExactSizeIterator,
@@ -1174,6 +1192,24 @@ impl<A, B> ZipImpl<A, B> for Zip<A, B>
  (len, Some(len))
  }
 
+ #[inline]
+ fn nth(&mut self, n: usize) -> Option<Self::Item> {
+ let delta = cmp::min(n, self.len - self.index);
+ let end = self.index + delta;
+ while self.index < end {
+ let i = self.index;
+ self.index += 1;
+ if A::may_have_side_effect() {
+ unsafe { self.a.get_unchecked(i); }
+ }
+ if B::may_have_side_effect() {
+ unsafe { self.b.get_unchecked(i); }
+ }
+ }
+
+ self.super_nth(n - delta)
+ }
+
  #[inline]
  fn next_back(&mut self) -> Option<(A::Item, B::Item)>
  where A: DoubleEndedIterator + ExactSizeIterator,

src/libcore/tests/iter.rs

@@ -144,6 +144,43 @@ fn test_iterator_chain_find() {
  assert_eq!(iter.next(), None);
 }
 
+#[test]
+fn test_zip_nth() {
+ let xs = [0, 1, 2, 4, 5];
+ let ys = [10, 11, 12];
+
+ let mut it = xs.iter().zip(&ys);
+ assert_eq!(it.nth(0), Some((&0, &10)));
+ assert_eq!(it.nth(1), Some((&2, &12)));
+ assert_eq!(it.nth(0), None);
+
+ let mut it = xs.iter().zip(&ys);
+ assert_eq!(it.nth(3), None);
+
+ let mut it = ys.iter().zip(&xs);
+ assert_eq!(it.nth(3), None);
+}
+
+#[test]
+fn test_zip_nth_side_effects() {
+ let mut a = Vec::new();
+ let mut b = Vec::new();
+ let value = [1, 2, 3, 4, 5, 6].iter().cloned()
+ .map(|n| {
+ a.push(n);
+ n * 10
+ })
+ .zip([2, 3, 4, 5, 6, 7, 8].iter().cloned().map(|n| {
+ b.push(n * 100);
+ n * 1000
+ }))
+ .skip(1)
+ .nth(3);
+ assert_eq!(value, Some((50, 6000)));
+ assert_eq!(a, vec![1, 2, 3, 4, 5]);
+ assert_eq!(b, vec![200, 300, 400, 500, 600]);
+}
+
 #[test]
 fn test_iterator_step_by() {
  // Identity

src/librustc/dep_graph/debug.rs

@@ -54,7 +54,7 @@ pub struct EdgeFilter {
 }
 
 impl EdgeFilter {
- pub fn new(test: &str) -> Result<EdgeFilter, Box<Error>> {
+ pub fn new(test: &str) -> Result<EdgeFilter, Box<dyn Error>> {
  let parts: Vec<_> = test.split("->").collect();
  if parts.len() != 2 {
  Err(format!("expected a filter like `a&b -> c&d`, not `{}`", test).into())

src/librustc/hir/lowering.rs

@@ -80,13 +80,13 @@ pub struct LoweringContext<'a> {
  // Use to assign ids to hir nodes that do not directly correspond to an ast node
  sess: &'a Session,
 
- cstore: &'a CrateStore,
+ cstore: &'a dyn CrateStore,
 
  // As we walk the AST we must keep track of the current 'parent' def id (in
  // the form of a DefIndex) so that if we create a new node which introduces
  // a definition, then we can properly create the def id.
  parent_def: Option<DefIndex>,
- resolver: &'a mut Resolver,
+ resolver: &'a mut dyn Resolver,
  name_map: FxHashMap<Ident, Name>,
 
  /// The items being lowered are collected here.
@@ -177,10 +177,10 @@ enum ImplTraitContext {
 }
 
 pub fn lower_crate(sess: &Session,
- cstore: &CrateStore,
+ cstore: &dyn CrateStore,
  dep_graph: &DepGraph,
  krate: &Crate,
- resolver: &mut Resolver)
+ resolver: &mut dyn Resolver)
  -> hir::Crate {
  // We're constructing the HIR here; we don't care what we will
  // read, since we haven't even constructed the *input* to

src/librustc/hir/map/collector.rs

@@ -123,7 +123,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
 
  pub(super) fn finalize_and_compute_crate_hash(self,
  crate_disambiguator: CrateDisambiguator,
- cstore: &CrateStore,
+ cstore: &dyn CrateStore,
  codemap: &CodeMap,
  commandline_args_hash: u64)
  -> (Vec<MapEntry<'hir>>, Svh) {

src/librustc/hir/map/def_collector.rs

@@ -26,7 +26,7 @@ pub struct DefCollector<'a> {
  definitions: &'a mut Definitions,
  parent_def: Option<DefIndex>,
  expansion: Mark,
- pub visit_macro_invoc: Option<&'a mut FnMut(MacroInvocationData)>,
+ pub visit_macro_invoc: Option<&'a mut dyn FnMut(MacroInvocationData)>,
 }
 
 pub struct MacroInvocationData {

src/librustc/hir/map/mod.rs

@@ -19,6 +19,8 @@ use dep_graph::{DepGraph, DepNode, DepKind, DepNodeIndex};
 
 use hir::def_id::{CRATE_DEF_INDEX, DefId, LocalDefId, DefIndexAddressSpace};
 
+use middle::cstore::CrateStore;
+
 use syntax::abi::Abi;
 use syntax::ast::{self, Name, NodeId, CRATE_NODE_ID};
 use syntax::codemap::Spanned;
@@ -1136,8 +1138,9 @@ impl Named for StructField { fn name(&self) -> Name { self.name } }
 impl Named for TraitItem { fn name(&self) -> Name { self.name } }
 impl Named for ImplItem { fn name(&self) -> Name { self.name } }
 
+
 pub fn map_crate<'hir>(sess: &::session::Session,
- cstore: &::middle::cstore::CrateStore,
+ cstore: &dyn CrateStore,
  forest: &'hir mut Forest,
  definitions: &'hir Definitions)
  -> Map<'hir> {

src/librustc/hir/print.rs

@@ -62,7 +62,7 @@ pub trait PpAnn {
 
 pub struct NoAnn;
 impl PpAnn for NoAnn {}
-pub const NO_ANN: &'static PpAnn = &NoAnn;
+pub const NO_ANN: &'static dyn PpAnn = &NoAnn;
 
 impl PpAnn for hir::Crate {
  fn nested(&self, state: &mut State, nested: Nested) -> io::Result<()> {
@@ -83,7 +83,7 @@ pub struct State<'a> {
  literals: Peekable<vec::IntoIter<comments::Literal>>,
  cur_cmnt: usize,
  boxes: Vec<pp::Breaks>,
- ann: &'a (PpAnn + 'a),
+ ann: &'a (dyn PpAnn + 'a),
 }
 
 impl<'a> PrintState<'a> for State<'a> {
@@ -126,9 +126,9 @@ pub fn print_crate<'a>(cm: &'a CodeMap,
  sess: &ParseSess,
  krate: &hir::Crate,
  filename: FileName,
- input: &mut Read,
- out: Box<Write + 'a>,
- ann: &'a PpAnn,
+ input: &mut dyn Read,
+ out: Box<dyn Write + 'a>,
+ ann: &'a dyn PpAnn,
  is_expanded: bool)
  -> io::Result<()> {
  let mut s = State::new_from_input(cm, sess, filename, input, out, ann, is_expanded);
@@ -145,9 +145,9 @@ impl<'a> State<'a> {
  pub fn new_from_input(cm: &'a CodeMap,
  sess: &ParseSess,
  filename: FileName,
- input: &mut Read,
- out: Box<Write + 'a>,
- ann: &'a PpAnn,
+ input: &mut dyn Read,
+ out: Box<dyn Write + 'a>,
+ ann: &'a dyn PpAnn,
  is_expanded: bool)
  -> State<'a> {
  let (cmnts, lits) = comments::gather_comments_and_literals(sess, filename, input);
@@ -167,8 +167,8 @@ impl<'a> State<'a> {
  }
 
  pub fn new(cm: &'a CodeMap,
- out: Box<Write + 'a>,
- ann: &'a PpAnn,
+ out: Box<dyn Write + 'a>,
+ ann: &'a dyn PpAnn,
  comments: Option<Vec<comments::Comment>>,
  literals: Option<Vec<comments::Literal>>)
  -> State<'a> {
@@ -184,7 +184,7 @@ impl<'a> State<'a> {
  }
 }
 
-pub fn to_string<F>(ann: &PpAnn, f: F) -> String
+pub fn to_string<F>(ann: &dyn PpAnn, f: F) -> String
  where F: FnOnce(&mut State) -> io::Result<()>
 {
  let mut wr = Vec::new();