Merge remote-tracking branch 'origin/master' into proc_macro_api

Author: alexcrichton

.gitignore

@@ -51,6 +51,7 @@
 .hg/
 .hgignore
 .idea
+*.iml
 __pycache__/
 *.py[cod]
 *$py.class

.travis.yml

@@ -171,16 +171,22 @@ before_script:
       if [[ "$SKIP_BUILD" == true ]]; then
           export RUN_SCRIPT="echo 'skipping, not a full build'";
       else
-          RUN_SCRIPT="stamp src/ci/init_repo.sh . $HOME/rustsrc";
+          RUN_SCRIPT="src/ci/init_repo.sh . $HOME/rustsrc";
           if [ "$TRAVIS_OS_NAME" = "osx" ]; then
-              export RUN_SCRIPT="$RUN_SCRIPT && stamp src/ci/run.sh";
+              export RUN_SCRIPT="$RUN_SCRIPT && src/ci/run.sh";
           else
-              export RUN_SCRIPT="$RUN_SCRIPT && stamp src/ci/docker/run.sh $IMAGE";
+              export RUN_SCRIPT="$RUN_SCRIPT && src/ci/docker/run.sh $IMAGE";
           fi
       fi
 
+# Log time information from this machine and an external machine for insight into possible
+# clock drift. Timezones don't matter since relative deltas give all the necessary info.
 script:
-  - sh -x -c "$RUN_SCRIPT"
+  - >
+      date && curl -s --head https://google.com | grep ^Date: | sed 's/Date: //g'
+  - stamp sh -x -c "$RUN_SCRIPT"
+  - >
+      date && curl -s --head https://google.com | grep ^Date: | sed 's/Date: //g'
 
 after_success:
   - >

README.md

@@ -40,8 +40,9 @@ Read ["Installation"] from [The Book].
 
     > ***Note:*** Install locations can be adjusted by copying the config file
     > from `./src/bootstrap/config.toml.example` to `./config.toml`, and
-    > adjusting the `prefix` option under `[install]`. Various other options are
-    > also supported, and are documented in the config file.
+    > adjusting the `prefix` option under `[install]`. Various other options, such
+    > as enabling debug information, are also supported, and are documented in
+    > the config file.
 
     When complete, `sudo ./x.py install` will place several programs into
     `/usr/local/bin`: `rustc`, the Rust compiler, and `rustdoc`, the

src/Cargo.lock

@@ -75,16 +75,11 @@ fn main() {
         Err(_) => 0,
     };
 
-    // Build scripts always use the snapshot compiler which is guaranteed to be
-    // able to produce an executable, whereas intermediate compilers may not
-    // have the standard library built yet and may not be able to produce an
-    // executable. Otherwise we just use the standard compiler we're
-    // bootstrapping with.
-    //
-    // Also note that cargo will detect the version of the compiler to trigger
-    // a rebuild when the compiler changes. If this happens, we want to make
-    // sure to use the actual compiler instead of the snapshot compiler becase
-    // that's the one that's actually changing.
+    // Use a different compiler for build scripts, since there may not yet be a
+    // libstd for the real compiler to use. However, if Cargo is attempting to
+    // determine the version of the compiler, the real compiler needs to be
+    // used. Currently, these two states are differentiated based on whether
+    // --target and -vV is/isn't passed.
     let (rustc, libdir) = if target.is_none() && version.is_none() {
         ("RUSTC_SNAPSHOT", "RUSTC_SNAPSHOT_LIBDIR")
     } else {

src/bootstrap/bin/rustc.rs

@@ -25,10 +25,11 @@
 
 
 def get(url, path, verbose=False):
-    sha_url = url + ".sha256"
+    suffix = '.sha256'
+    sha_url = url + suffix
     with tempfile.NamedTemporaryFile(delete=False) as temp_file:
         temp_path = temp_file.name
-    with tempfile.NamedTemporaryFile(suffix=".sha256", delete=False) as sha_file:
+    with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as sha_file:
         sha_path = sha_file.name
 
     try:
@@ -55,6 +56,7 @@ def get(url, path, verbose=False):
 
 
 def delete_if_present(path, verbose):
+    """Remove the given file if present"""
     if os.path.isfile(path):
         if verbose:
             print("removing " + path)
@@ -92,12 +94,13 @@ def _download(path, url, probably_big, verbose, exception):
 
 
 def verify(path, sha_path, verbose):
+    """Check if the sha256 sum of the given path is valid"""
     if verbose:
         print("verifying " + path)
-    with open(path, "rb") as f:
-        found = hashlib.sha256(f.read()).hexdigest()
-    with open(sha_path, "r") as f:
-        expected = f.readline().split()[0]
+    with open(path, "rb") as source:
+        found = hashlib.sha256(source.read()).hexdigest()
+    with open(sha_path, "r") as sha256sum:
+        expected = sha256sum.readline().split()[0]
     verified = found == expected
     if not verified:
         print("invalid checksum:\n"
@@ -107,6 +110,7 @@ def verify(path, sha_path, verbose):
 
 
 def unpack(tarball, dst, verbose=False, match=None):
+    """Unpack the given tarball file"""
     print("extracting " + tarball)
     fname = os.path.basename(tarball).replace(".tar.gz", "")
     with contextlib.closing(tarfile.open(tarball)) as tar:
@@ -128,6 +132,7 @@ def unpack(tarball, dst, verbose=False, match=None):
             shutil.move(tp, fp)
     shutil.rmtree(os.path.join(dst, fname))
 
+
 def run(args, verbose=False, exception=False, **kwargs):
     if verbose:
         print("running: " + ' '.join(args))
@@ -245,7 +250,8 @@ def fix_executable(self, fname):
             return
 
         # At this point we're pretty sure the user is running NixOS
-        print("info: you seem to be running NixOS. Attempting to patch " + fname)
+        nix_os_msg = "info: you seem to be running NixOS. Attempting to patch"
+        print(nix_os_msg, fname)
 
         try:
             interpreter = subprocess.check_output(
@@ -293,18 +299,22 @@ def stage0_cargo_channel(self):
         return self._cargo_channel
 
     def rustc_stamp(self):
+        """Return the path for .rustc-stamp"""
         return os.path.join(self.bin_root(), '.rustc-stamp')
 
     def cargo_stamp(self):
+        """Return the path for .cargo-stamp"""
         return os.path.join(self.bin_root(), '.cargo-stamp')
 
     def rustc_out_of_date(self):
+        """Check if rustc is out of date"""
         if not os.path.exists(self.rustc_stamp()) or self.clean:
             return True
         with open(self.rustc_stamp(), 'r') as f:
             return self.stage0_date() != f.read()
 
     def cargo_out_of_date(self):
+        """Check if cargo is out of date"""
         if not os.path.exists(self.cargo_stamp()) or self.clean:
             return True
         with open(self.cargo_stamp(), 'r') as f:
@@ -357,16 +367,15 @@ def get_string(self, line):
     def exe_suffix(self):
         if sys.platform == 'win32':
             return '.exe'
-        else:
-            return ''
+        return ''
 
     def print_what_it_means_to_bootstrap(self):
         if hasattr(self, 'printed'):
             return
         self.printed = True
         if os.path.exists(self.bootstrap_binary()):
             return
-        if not '--help' in sys.argv or len(sys.argv) == 1:
+        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')
@@ -461,8 +470,8 @@ def build_triple(self):
             # always emit 'i386' on x86/amd64 systems).  As such, isainfo -k
             # must be used instead.
             try:
-                cputype = subprocess.check_output(['isainfo',
-                                                   '-k']).strip().decode(default_encoding)
+                cputype = subprocess.check_output(
+                    ['isainfo', '-k']).strip().decode(default_encoding)
             except (subprocess.CalledProcessError, OSError):
                 err = "isainfo not found"
                 if self.verbose:
@@ -562,21 +571,26 @@ def update_submodules(self):
         default_encoding = sys.getdefaultencoding()
         run(["git", "submodule", "-q", "sync"], cwd=self.rust_root)
         submodules = [s.split(' ', 1)[1] for s in subprocess.check_output(
-            ["git", "config", "--file", os.path.join(self.rust_root, ".gitmodules"),
+            ["git", "config", "--file",
+             os.path.join(self.rust_root, ".gitmodules"),
              "--get-regexp", "path"]
         ).decode(default_encoding).splitlines()]
         submodules = [module for module in submodules
                       if not ((module.endswith("llvm") and
-                               (self.get_toml('llvm-config') or self.get_mk('CFG_LLVM_ROOT'))) or
+                               (self.get_toml('llvm-config') or
+                                self.get_mk('CFG_LLVM_ROOT'))) or
                               (module.endswith("jemalloc") and
-                               (self.get_toml('jemalloc') or self.get_mk('CFG_JEMALLOC_ROOT'))))
-                     ]
+                               (self.get_toml('jemalloc') or
+                                self.get_mk('CFG_JEMALLOC_ROOT'))))]
         run(["git", "submodule", "update",
-                  "--init"] + submodules, cwd=self.rust_root, verbose=self.verbose)
+             "--init"] + submodules,
+            cwd=self.rust_root, verbose=self.verbose)
         run(["git", "submodule", "-q", "foreach", "git",
-                  "reset", "-q", "--hard"], cwd=self.rust_root, verbose=self.verbose)
+             "reset", "-q", "--hard"],
+            cwd=self.rust_root, verbose=self.verbose)
         run(["git", "submodule", "-q", "foreach", "git",
-                  "clean", "-qdfx"], cwd=self.rust_root, verbose=self.verbose)
+             "clean", "-qdfx"],
+            cwd=self.rust_root, verbose=self.verbose)
 
 
 def bootstrap():
@@ -692,5 +706,6 @@ def main():
                   format_build_time(time() - start_time))
         sys.exit(exit_code)
 
+
 if __name__ == '__main__':
     main()

src/bootstrap/bootstrap.py

@@ -42,10 +42,13 @@ use config::Target;
 pub fn find(build: &mut Build) {
     // For all targets we're going to need a C compiler for building some shims
     // and such as well as for being a linker for Rust code.
-    for target in build.config.target.iter() {
+    //
+    // This includes targets that aren't necessarily passed on the commandline
+    // (FIXME: Perhaps it shouldn't?)
+    for target in &build.config.target {
         let mut cfg = gcc::Config::new();
         cfg.cargo_metadata(false).opt_level(0).debug(false)
-           .target(target).host(&build.config.build);
+           .target(target).host(&build.build);
 
         let config = build.config.target_config.get(target);
         if let Some(cc) = config.and_then(|c| c.cc.as_ref()) {
@@ -64,10 +67,13 @@ pub fn find(build: &mut Build) {
     }
 
     // For all host triples we need to find a C++ compiler as well
-    for host in build.config.host.iter() {
+    //
+    // This includes hosts that aren't necessarily passed on the commandline
+    // (FIXME: Perhaps it shouldn't?)
+    for host in &build.config.host {
         let mut cfg = gcc::Config::new();
         cfg.cargo_metadata(false).opt_level(0).debug(false).cpp(true)
-           .target(host).host(&build.config.build);
+           .target(host).host(&build.build);
         let config = build.config.target_config.get(host);
         if let Some(cxx) = config.and_then(|c| c.cxx.as_ref()) {
             cfg.compiler(cxx);

src/bootstrap/cc.rs

@@ -23,12 +23,12 @@ use build_helper::output;
 use Build;
 
 // The version number
-pub const CFG_RELEASE_NUM: &'static str = "1.20.0";
+pub const CFG_RELEASE_NUM: &str = "1.20.0";
 
 // An optional number to put after the label, e.g. '.2' -> '-beta.2'
 // Be sure to make this starts with a dot to conform to semver pre-release
 // versions (section 9)
-pub const CFG_PRERELEASE_VERSION: &'static str = ".1";
+pub const CFG_PRERELEASE_VERSION: &str = ".1";
 
 pub struct GitInfo {
     inner: Option<Info>,
@@ -99,6 +99,10 @@ impl GitInfo {
             version.push_str(&inner.commit_date);
             version.push_str(")");
         }
-        return version
+        version
+    }
+
+    pub fn is_git(&self) -> bool {
+        self.inner.is_some()
     }
 }