Auto merge of #5032 - matklad:lazycell, r=alexcrichton

Switch to lazycell from crate.io

This switches from a home-grown implementation of `lazycell` to the one from crates.io.

There are no particularly large improvements here, but our own lazy cell is definitely unsafe in theory, because of potential reentrancy in `get_or_try_init`, and the one from crates.io does not have at least this hole :-)

Note that `rustc` already has `lazycell` in its Cargo.lock (because of clippy I guess?), albeit with a lower version, 0.5.

Author: bors

Cargo.toml

@@ -35,6 +35,7 @@ hex = "0.3"
 home = "0.3"
 ignore = "0.3"
 jobserver = "0.1.9"
+lazycell = "0.6"
 libc = "0.2"
 libgit2-sys = "0.6"
 log = "0.4"

src/cargo/core/package.rs

@@ -7,11 +7,12 @@ use std::path::{Path, PathBuf};
 use semver::Version;
 use serde::ser;
 use toml;
+use lazycell::LazyCell;
 
 use core::{Dependency, Manifest, PackageId, SourceId, Target};
 use core::{Summary, SourceMap};
 use ops;
-use util::{Config, LazyCell, internal, lev_distance};
+use util::{Config, internal, lev_distance};
 use util::errors::{CargoResult, CargoResultExt};
 
 /// Information about a package that is available somewhere in the file system.

src/cargo/lib.rs

@@ -21,6 +21,7 @@ extern crate hex;
 extern crate home;
 extern crate ignore;
 extern crate jobserver;
+extern crate lazycell;
 extern crate libc;
 extern crate libgit2_sys;
 extern crate num_cpus;

src/cargo/ops/cargo_rustc/compilation.rs

@@ -1,10 +1,12 @@
 use std::collections::{HashMap, HashSet, BTreeSet};
 use std::ffi::OsStr;
 use std::path::PathBuf;
+
 use semver::Version;
+use lazycell::LazyCell;
 
 use core::{PackageId, Package, Target, TargetKind};
-use util::{self, CargoResult, Config, LazyCell, ProcessBuilder, process, join_paths};
+use util::{self, CargoResult, Config, ProcessBuilder, process, join_paths};
 
 /// A structure returning the result of a compilation.
 pub struct Compilation<'cfg> {
@@ -101,7 +103,7 @@ impl<'cfg> Compilation<'cfg> {
     }
 
     fn target_runner(&self) -> CargoResult<&Option<(PathBuf, Vec<String>)>> {
-        self.target_runner.get_or_try_init(|| {
+        self.target_runner.try_borrow_with(|| {
             let key = format!("target.{}.runner", self.target);
             Ok(self.config.get_path_and_args(&key)?.map(|v| v.val))
         })

src/cargo/sources/registry/remote.rs

@@ -9,12 +9,13 @@ use std::str;
 use git2;
 use hex;
 use serde_json;
+use lazycell::LazyCell;
 
 use core::{PackageId, SourceId};
 use sources::git;
 use sources::registry::{RegistryData, RegistryConfig, INDEX_LOCK, CRATE_TEMPLATE, VERSION_TEMPLATE};
 use util::network;
-use util::{FileLock, Filesystem, LazyCell};
+use util::{FileLock, Filesystem};
 use util::{Config, Sha256, ToUrl, Progress};
 use util::errors::{CargoResult, CargoResultExt, HttpNot200};
 
@@ -43,7 +44,7 @@ impl<'cfg> RemoteRegistry<'cfg> {
     }
 
     fn repo(&self) -> CargoResult<&git2::Repository> {
-        self.repo.get_or_try_init(|| {
+        self.repo.try_borrow_with(|| {
             let path = self.index_path.clone().into_path_unlocked();
 
             // Fast path without a lock

src/cargo/util/config.rs

@@ -16,6 +16,7 @@ use curl::easy::Easy;
 use jobserver;
 use serde::{Serialize, Serializer};
 use toml;
+use lazycell::LazyCell;
 
 use core::shell::Verbosity;
 use core::{Shell, CliUnstable};
@@ -26,7 +27,7 @@ use util::Rustc;
 use util::errors::{CargoResult, CargoResultExt, CargoError, internal};
 use util::paths;
 use util::toml as cargo_toml;
-use util::{Filesystem, LazyCell};
+use util::Filesystem;
 
 use self::ConfigValue as CV;
 
@@ -144,18 +145,18 @@ impl Config {
 
     /// Get the path to the `rustdoc` executable
     pub fn rustdoc(&self) -> CargoResult<&Path> {
-        self.rustdoc.get_or_try_init(|| self.get_tool("rustdoc")).map(AsRef::as_ref)
+        self.rustdoc.try_borrow_with(|| self.get_tool("rustdoc")).map(AsRef::as_ref)
     }
 
     /// Get the path to the `rustc` executable
     pub fn rustc(&self) -> CargoResult<&Rustc> {
-        self.rustc.get_or_try_init(|| Rustc::new(self.get_tool("rustc")?,
+        self.rustc.try_borrow_with(|| Rustc::new(self.get_tool("rustc")?,
                                                  self.maybe_get_tool("rustc_wrapper")?))
     }
 
     /// Get the path to the `cargo` executable
     pub fn cargo_exe(&self) -> CargoResult<&Path> {
-        self.cargo_exe.get_or_try_init(|| {
+        self.cargo_exe.try_borrow_with(|| {
             fn from_current_exe() -> CargoResult<PathBuf> {
                 // Try fetching the path to `cargo` using env::current_exe().
                 // The method varies per operating system and might fail; in particular,
@@ -207,7 +208,7 @@ impl Config {
     }
 
     pub fn values(&self) -> CargoResult<&HashMap<String, ConfigValue>> {
-        self.values.get_or_try_init(|| self.load_values())
+        self.values.try_borrow_with(|| self.load_values())
     }
 
     pub fn set_values(&self, values: HashMap<String, ConfigValue>) -> CargoResult<()> {
@@ -648,7 +649,7 @@ impl Config {
     }
 
     pub fn http(&self) -> CargoResult<&RefCell<Easy>> {
-        let http = self.easy.get_or_try_init(|| {
+        let http = self.easy.try_borrow_with(|| {
             ops::http_handle(self).map(RefCell::new)
         })?;
         {

src/cargo/util/lazy_cell.rs

@@ -7,7 +7,6 @@ pub use self::errors::{process_error, internal};
 pub use self::flock::{FileLock, Filesystem};
 pub use self::graph::Graph;
 pub use self::hex::{to_hex, short_hash, hash_u64};
-pub use self::lazy_cell::LazyCell;
 pub use self::lev_distance::{lev_distance};
 pub use self::paths::{join_paths, path2bytes, bytes2path, dylib_path};
 pub use self::paths::{normalize_path, dylib_path_envvar, without_prefix};
@@ -40,7 +39,6 @@ mod dependency_queue;
 mod rustc;
 mod sha256;
 mod vcs;
-mod lazy_cell;
 mod flock;
 mod read2;
 mod progress;