…e methods

It’s not entirely clear from the current documentation what behaviour
calling a method such as `min` on an infinite iterator like `RangeFrom`
is. One might expect this to terminate, but in fact, for infinite
iterators, `min` is always nonterminating (at least in the standard
library). This adds a quick note about this behaviour for clarification.

config.toml.example

@@ -151,6 +151,10 @@
# default.
#extended = false

# Installs choosen set of extended tools if enables. By default builds all.
# If choosen tool failed to build the installation fails.
#tools = ["cargo", "rls", "rustfmt", "analysis", "src"]

# Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose
#verbose = 0

src/bootstrap/builder.rs

@@ -570,7 +570,7 @@ impl<'a> Builder<'a> {
        // build scripts in that situation.
        //
        // If LLVM support is disabled we need to use the snapshot compiler to compile
        // build scripts, as the new compiler doesnt support executables.
        // build scripts, as the new compiler doesn't support executables.
        if mode == Mode::Libstd || !self.build.config.llvm_enabled {
            cargo.env("RUSTC_SNAPSHOT", &self.initial_rustc)
                 .env("RUSTC_SNAPSHOT_LIBDIR", self.rustc_snapshot_libdir());
@@ -600,9 +600,25 @@ impl<'a> Builder<'a> {
        //
        // FIXME: the guard against msvc shouldn't need to be here
        if !target.contains("msvc") {
            let cc = self.cc(target);
            cargo.env(format!("CC_{}", target), cc)
                 .env("CC", cc);
            let ccache = self.config.ccache.as_ref();
            let ccacheify = |s: &Path| {
                let ccache = match ccache {
                    Some(ref s) => s,
                    None => return s.display().to_string(),
                };
                // FIXME: the cc-rs crate only recognizes the literal strings
                // `ccache` and `sccache` when doing caching compilations, so we
                // mirror that here. It should probably be fixed upstream to
                // accept a new env var or otherwise work with custom ccache
                // vars.
                match &ccache[..] {
                    "ccache" | "sccache" => format!("{} {}", ccache, s.display()),
                    _ => s.display().to_string(),
                }
            };
            let cc = ccacheify(&self.cc(target));
            cargo.env(format!("CC_{}", target), &cc)
                 .env("CC", &cc);

            let cflags = self.cflags(target).join(" ");
            cargo.env(format!("CFLAGS_{}", target), cflags.clone())
@@ -617,8 +633,9 @@ impl<'a> Builder<'a> {
            }

            if let Ok(cxx) = self.cxx(target) {
                cargo.env(format!("CXX_{}", target), cxx)
                     .env("CXX", cxx)
                let cxx = ccacheify(&cxx);
                cargo.env(format!("CXX_{}", target), &cxx)
                     .env("CXX", &cxx)
                     .env(format!("CXXFLAGS_{}", target), cflags.clone())
                     .env("CXXFLAGS", cflags);
            }

src/bootstrap/config.rs

@@ -13,7 +13,7 @@
//! This module implements parsing `config.toml` configuration files to tweak
//! how the build runs.

use std::collections::HashMap;
use std::collections::{HashMap, HashSet};
use std::env;
use std::fs::File;
use std::io::prelude::*;
@@ -52,6 +52,7 @@ pub struct Config {
    pub target_config: HashMap<Interned<String>, Target>,
    pub full_bootstrap: bool,
    pub extended: bool,
    pub tools: Option<HashSet<String>>,
    pub sanitizers: bool,
    pub profiler: bool,
    pub ignore_git: bool,
@@ -191,6 +192,7 @@ struct Build {
    python: Option<String>,
    full_bootstrap: Option<bool>,
    extended: Option<bool>,
    tools: Option<HashSet<String>>,
    verbose: Option<usize>,
    sanitizers: Option<bool>,
    profiler: Option<bool>,
@@ -395,6 +397,7 @@ impl Config {
        set(&mut config.vendor, build.vendor);
        set(&mut config.full_bootstrap, build.full_bootstrap);
        set(&mut config.extended, build.extended);
        config.tools = build.tools;
        set(&mut config.verbose, build.verbose);
        set(&mut config.sanitizers, build.sanitizers);
        set(&mut config.profiler, build.profiler);

src/bootstrap/configure.py

@@ -144,6 +144,7 @@ def v(*args):
o("full-bootstrap", "build.full-bootstrap", "build three compilers instead of two")
o("extended", "build.extended", "build an extended rust tool set")

v("tools", "build.tools", "List of extended tools will be installed")
v("build", "build.build", "GNUs ./configure syntax LLVM build triple")
v("host", None, "GNUs ./configure syntax LLVM host triples")
v("target", None, "GNUs ./configure syntax LLVM target triples")

src/bootstrap/dist.rs

@@ -31,6 +31,7 @@ use channel;
use util::{cp_r, libdir, is_dylib, cp_filtered, copy, replace_in_file};
use builder::{Builder, RunConfig, ShouldRun, Step};
use compile;
use native;
use tool::{self, Tool};
use cache::{INTERNER, Interned};
use time;
@@ -898,6 +899,12 @@ impl Step for PlainSourceTarball {
                   .arg("--vers").arg(CARGO_VENDOR_VERSION)
                   .arg("cargo-vendor")
                   .env("RUSTC", &build.initial_rustc);
                if let Some(dir) = build.openssl_install_dir(build.config.build) {
                    builder.ensure(native::Openssl {
                        target: build.config.build,
                    });
                    cmd.env("OPENSSL_DIR", dir);
                }
                build.run(&mut cmd);
            }

src/bootstrap/install.rs

@@ -22,6 +22,7 @@ use dist::{self, pkgname, sanitize_sh, tmpdir};

use builder::{Builder, RunConfig, ShouldRun, Step};
use cache::Interned;
use config::Config;

pub fn install_docs(builder: &Builder, stage: u32, host: Interned<String>) {
    install_sh(builder, "docs", "rust-docs", stage, Some(host));
@@ -144,6 +145,19 @@ macro_rules! install {
            pub host: Interned<String>,
        }

        impl $name {
            #[allow(dead_code)]
            fn should_build(config: &Config) -> bool {
                config.extended && config.tools.as_ref()
                    .map_or(true, |t| t.contains($path))
            }

            #[allow(dead_code)]
            fn should_install(builder: &Builder) -> bool {
                builder.config.tools.as_ref().map_or(false, |t| t.contains($path))
            }
        }

        impl Step for $name {
            type Output = ();
            const DEFAULT: bool = true;
@@ -185,32 +199,34 @@ install!((self, builder, _config),
            install_std(builder, self.stage, *target);
        }
    };
    Cargo, "cargo", _config.extended, only_hosts: true, {
    Cargo, "cargo", Self::should_build(_config), only_hosts: true, {
        builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
        install_cargo(builder, self.stage, self.target);
    };
    Rls, "rls", _config.extended, only_hosts: true, {
        if builder.ensure(dist::Rls { stage: self.stage, target: self.target }).is_some() {
    Rls, "rls", Self::should_build(_config), only_hosts: true, {
        if builder.ensure(dist::Rls { stage: self.stage, target: self.target }).is_some() ||
            Self::should_install(builder) {
            install_rls(builder, self.stage, self.target);
        } else {
            println!("skipping Install RLS stage{} ({})", self.stage, self.target);
        }
    };
    Rustfmt, "rustfmt", _config.extended, only_hosts: true, {
        if builder.ensure(dist::Rustfmt { stage: self.stage, target: self.target }).is_some() {
    Rustfmt, "rustfmt", Self::should_build(_config), only_hosts: true, {
        if builder.ensure(dist::Rustfmt { stage: self.stage, target: self.target }).is_some() ||
            Self::should_install(builder) {
            install_rustfmt(builder, self.stage, self.target);
        } else {
            println!("skipping Install Rustfmt stage{} ({})", self.stage, self.target);
        }
    };
    Analysis, "analysis", _config.extended, only_hosts: false, {
    Analysis, "analysis", Self::should_build(_config), only_hosts: false, {
        builder.ensure(dist::Analysis {
            compiler: builder.compiler(self.stage, self.host),
            target: self.target
        });
        install_analysis(builder, self.stage, self.target);
    };
    Src, "src", _config.extended, only_hosts: true, {
    Src, "src", Self::should_build(_config) , only_hosts: true, {
        builder.ensure(dist::Src);
        install_src(builder, self.stage);
    }, ONLY_BUILD;

src/bootstrap/lib.rs

@@ -666,7 +666,7 @@ impl Build {
        }
    }

    /// Returns the path to the linker for the given target if it needs to be overriden.
    /// Returns the path to the linker for the given target if it needs to be overridden.
    fn linker(&self, target: Interned<String>) -> Option<&Path> {
        if let Some(linker) = self.config.target_config.get(&target)
                                                       .and_then(|c| c.linker.as_ref()) {

src/bootstrap/native.rs

@@ -186,7 +186,7 @@ impl Step for Llvm {
        }

        // http://llvm.org/docs/HowToCrossCompileLLVM.html
        if target != build.build {
        if target != build.build && !emscripten {
            builder.ensure(Llvm {
                target: build.build,
                emscripten: false,

src/bootstrap/test.rs

@@ -902,7 +902,7 @@ impl Step for Compiletest {
            }
        }
        if suite == "run-make" && !build.config.llvm_enabled {
            println!("Ignoring run-make test suite as they generally dont work without LLVM");
            println!("Ignoring run-make test suite as they generally don't work without LLVM");
            return;
        }

src/ci/docker/dist-i686-freebsd/Dockerfile

@@ -1,4 +1,4 @@
FROM ubuntu:16.04
FROM ubuntu:18.04

RUN apt-get update && apt-get install -y --no-install-recommends \
  clang \

src/ci/docker/dist-i686-linux/Dockerfile

@@ -86,7 +86,8 @@ ENV RUST_CONFIGURE_ARGS \
      --enable-extended \
      --enable-sanitizers \
      --enable-profiler \
      --enable-emscripten
      --enable-emscripten \
      --build=i686-unknown-linux-gnu
ENV SCRIPT python2.7 ../x.py dist --host $HOSTS --target $HOSTS

# This is the only builder which will create source tarballs

src/ci/docker/dist-x86_64-netbsd/build-netbsd-toolchain.sh

@@ -54,7 +54,7 @@ cd usr/src
# The options, in order, do the following
# * this is an unprivileged build
# * output to a predictable location
# * disable various uneeded stuff
# * disable various unneeded stuff
MKUNPRIVED=yes TOOLDIR=/x-tools/x86_64-unknown-netbsd \
MKSHARE=no MKDOC=no MKHTML=no MKINFO=no MKKMOD=no MKLINT=no MKMAN=no MKNLS=no MKPROFILE=no \
hide_output ./build.sh -j10 -m amd64 tools

src/etc/installer/msi/rust.wxs

@@ -18,7 +18,7 @@
    <!-- Upgrade code should be different for each platform -->
    <?if $(sys.BUILDARCH)="x64" ?>
        <?if $(env.CFG_ABI)="GNU" ?>
            <!-- UpgradeCode shoud stay the same for all MSI versions in channel -->
            <!-- UpgradeCode should stay the same for all MSI versions in channel -->
            <?if $(env.CFG_CHANNEL)="stable" ?>
                <?define UpgradeCode="B440B077-F8D1-4730-8E1D-D6D37702B4CE" ?>
            <?elseif $(env.CFG_CHANNEL)="beta" ?>
@@ -129,7 +129,7 @@

        <!-- Path of cmd.exe for the shortcut -->
        <Property Id="SHORTCUTTARGET" Value="%windir%\System32\cmd.exe" />
        <!-- Microsoft Installer will resolve any Enviroment Variables in the working directory at install time -->
        <!-- Microsoft Installer will resolve any Environment Variables in the working directory at install time -->
        <Property Id="SHORTCUTWKDIR" Value="%SystemDrive%\" />

        <InstallUISequence>

src/etc/platform-intrinsics/generator.py

@@ -591,7 +591,7 @@ def parse_args():
        The X86 architecture is specified as multiple files (for the different
        instruction sets that x86 supports). To generate the compiler
        definitions one needs to pass the script a "platform information file"
        (with the -i flag) next to the files of the different intruction sets.
        (with the -i flag) next to the files of the different instruction sets.
        For example, to generate the X86 compiler-definitions for SSE4.2, just:

        python generator.py --format compiler-defs -i x86/info.json sse42.json

src/etc/test-float-parse/runtests.py

@@ -41,7 +41,7 @@
(as a fraction, using the ``fractions`` module).

Given an input string and the corresponding float computed via Rust, simply
decode the float into f * 2^k (for intergers f, k) and the ULP.
decode the float into f * 2^k (for integers f, k) and the ULP.
We can now easily compute the error and check if it is within 0.5 ULP as it
should be. Zero and infinites are handled similarly:

src/libbacktrace/ltmain.sh

@@ -487,7 +487,7 @@ func_mkdir_p ()
      # While some portion of DIR does not yet exist...
      while test ! -d "$my_directory_path"; do
        # ...make a list in topmost first order.  Use a colon delimited
	# list incase some portion of path contains whitespace.
	# list in case some portion of path contains whitespace.
        my_dir_list="$my_directory_path:$my_dir_list"

        # If the last portion added has no slash in it, the list is done

src/libbacktrace/macho.c

@@ -327,7 +327,7 @@ macho_get_commands (struct backtrace_state *state, int descriptor,
        goto end;
      file_header_view_valid = 1;

      // The endianess of the slice may be different than the fat image
      // The endianness of the slice may be different than the fat image
      switch (*(uint32_t *) file_header_view.data)
        {
          case MH_MAGIC:

src/libcore/char.rs

@@ -211,7 +211,7 @@ impl From<u8> for char {

/// An error which can be returned when parsing a char.
#[stable(feature = "char_from_str", since = "1.20.0")]
#[derive(Clone, Debug)]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ParseCharError {
    kind: CharErrorKind,
}

src/libcore/iter/iterator.rs

@@ -1431,6 +1431,10 @@ pub trait Iterator {
    /// Folding is useful whenever you have a collection of something, and want
    /// to produce a single value from it.
    ///
    /// Note: `fold()`, and similar methods that traverse the entire iterator,
    /// may not terminate for infinite iterators, even on traits for which a
    /// result is determinable in finite time.
    ///
    /// # Examples
    ///
    /// Basic usage:

src/libcore/iter/mod.rs

@@ -298,7 +298,21 @@
//!
//! This will print the numbers `0` through `4`, each on their own line.
//!
//! Bear in mind that methods on infinite iterators, even those for which a
//! result can be determined mathematically in finite time, may not terminate.
//! Specifically, methods such as [`min`], which in the general case require
//! traversing every element in the iterator, are likely not to return
//! successfully for any infinite iterators.
//!
//! ```no_run
//! let ones = std::iter::repeat(1);
//! let least = ones.min().unwrap(); // Oh no! An infinite loop!
//! // `ones.min()` causes an infinite loop, so we won't reach this point!
//! println!("The smallest number one is {}.", least);
//! ```
//!
//! [`take`]: trait.Iterator.html#method.take
//! [`min`]: trait.Iterator.html#method.min

#![stable(feature = "rust1", since = "1.0.0")]

src/libcore/macros.rs

@@ -327,7 +327,7 @@ macro_rules! debug_assert_ne {
///     }
/// }
///
/// // The prefered method of quick returning Errors
/// // The preferred method of quick returning Errors
/// fn write_to_file_question() -> Result<(), MyError> {
///     let mut file = File::create("my_best_friends.txt")?;
///     file.write_all(b"This is a list of my best friends.")?;

src/libcore/ops/arith.rs

@@ -181,7 +181,7 @@ add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// ```
#[lang = "sub"]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_on_unimplemented(message="cannot substract `{RHS}` from `{Self}`",
#[rustc_on_unimplemented(message="cannot subtract `{RHS}` from `{Self}`",
                         label="no implementation for `{Self} - {RHS}`")]
pub trait Sub<RHS=Self> {
    /// The resulting type after applying the `-` operator.
@@ -716,7 +716,7 @@ add_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }
/// ```
#[lang = "sub_assign"]
#[stable(feature = "op_assign_traits", since = "1.8.0")]
#[rustc_on_unimplemented(message="cannot substract-assign `{Rhs}` from `{Self}`",
#[rustc_on_unimplemented(message="cannot subtract-assign `{Rhs}` from `{Self}`",
                         label="no implementation for `{Self} -= {Rhs}`")]
pub trait SubAssign<Rhs=Self> {
    /// Performs the `-=` operation.