Remove lifetime from Unit

Author: alexcrichton

src/cargo/core/compiler/build_context/mod.rs

@@ -26,17 +26,17 @@ pub struct BuildContext<'a, 'cfg> {
     pub profiles: Profiles,
     pub build_config: &'a BuildConfig,
     /// Extra compiler args for either `rustc` or `rustdoc`.
-    pub extra_compiler_args: HashMap<Unit<'a>, Vec<String>>,
+    pub extra_compiler_args: HashMap<Unit, Vec<String>>,
     /// Package downloader.
     ///
     /// This holds ownership of the `Package` objects.
     pub packages: PackageSet<'cfg>,
     /// Information about rustc and the target platform.
     pub target_data: RustcTargetData,
     /// The root units of `unit_graph` (units requested on the command-line).
-    pub roots: Vec<Unit<'a>>,
+    pub roots: Vec<Unit>,
     /// The dependency graph of units to compile.
-    pub unit_graph: UnitGraph<'a>,
+    pub unit_graph: UnitGraph,
 }
 
 impl<'a, 'cfg> BuildContext<'a, 'cfg> {
@@ -45,10 +45,10 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
         packages: PackageSet<'cfg>,
         build_config: &'a BuildConfig,
         profiles: Profiles,
-        extra_compiler_args: HashMap<Unit<'a>, Vec<String>>,
+        extra_compiler_args: HashMap<Unit, Vec<String>>,
         target_data: RustcTargetData,
-        roots: Vec<Unit<'a>>,
-        unit_graph: UnitGraph<'a>,
+        roots: Vec<Unit>,
+        unit_graph: UnitGraph,
     ) -> CargoResult<BuildContext<'a, 'cfg>> {
         Ok(BuildContext {
             ws,
@@ -91,19 +91,19 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
         self.build_config.jobs
     }
 
-    pub fn rustflags_args(&self, unit: &Unit<'_>) -> &[String] {
+    pub fn rustflags_args(&self, unit: &Unit) -> &[String] {
         &self.target_data.info(unit.kind).rustflags
     }
 
-    pub fn rustdocflags_args(&self, unit: &Unit<'_>) -> &[String] {
+    pub fn rustdocflags_args(&self, unit: &Unit) -> &[String] {
         &self.target_data.info(unit.kind).rustdocflags
     }
 
     pub fn show_warnings(&self, pkg: PackageId) -> bool {
         pkg.source_id().is_path() || self.config.extra_verbose()
     }
 
-    pub fn extra_args_for(&self, unit: &Unit<'a>) -> Option<&Vec<String>> {
+    pub fn extra_args_for(&self, unit: &Unit) -> Option<&Vec<String>> {
         self.extra_compiler_args.get(unit)
     }
 }

src/cargo/core/compiler/build_plan.rs

@@ -45,7 +45,7 @@ struct SerializedBuildPlan {
 }
 
 impl Invocation {
-    pub fn new(unit: &Unit<'_>, deps: Vec<usize>) -> Invocation {
+    pub fn new(unit: &Unit, deps: Vec<usize>) -> Invocation {
         let id = unit.pkg.package_id();
         Invocation {
             package_name: id.name().to_string(),
@@ -109,7 +109,7 @@ impl BuildPlan {
         }
     }
 
-    pub fn add<'a>(&mut self, cx: &Context<'a, '_>, unit: &Unit<'a>) -> CargoResult<()> {
+    pub fn add(&mut self, cx: &Context<'_, '_>, unit: &Unit) -> CargoResult<()> {
         let id = self.plan.invocations.len();
         self.invocation_map.insert(unit.buildkey(), id);
         let deps = cx

src/cargo/core/compiler/context/compilation_files.rs

@@ -82,15 +82,15 @@ pub struct CompilationFiles<'a, 'cfg> {
     export_dir: Option<PathBuf>,
     /// The root targets requested by the user on the command line (does not
     /// include dependencies).
-    roots: Vec<Unit<'a>>,
+    roots: Vec<Unit>,
     ws: &'a Workspace<'cfg>,
     /// Metadata hash to use for each unit.
     ///
     /// `None` if the unit should not use a metadata data hash (like rustdoc,
     /// or some dylibs).
-    metas: HashMap<Unit<'a>, Option<Metadata>>,
+    metas: HashMap<Unit, Option<Metadata>>,
     /// For each Unit, a list all files produced.
-    outputs: HashMap<Unit<'a>, LazyCell<Arc<Vec<OutputFile>>>>,
+    outputs: HashMap<Unit, LazyCell<Arc<Vec<OutputFile>>>>,
 }
 
 /// Info about a single file emitted by the compiler.
@@ -158,20 +158,20 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     ///
     /// Returns `None` if the unit should not use a metadata data hash (like
     /// rustdoc, or some dylibs).
-    pub fn metadata(&self, unit: &Unit<'a>) -> Option<Metadata> {
+    pub fn metadata(&self, unit: &Unit) -> Option<Metadata> {
         self.metas[unit]
     }
 
     /// Gets the short hash based only on the `PackageId`.
     /// Used for the metadata when `metadata` returns `None`.
-    pub fn target_short_hash(&self, unit: &Unit<'_>) -> String {
+    pub fn target_short_hash(&self, unit: &Unit) -> String {
         let hashable = unit.pkg.package_id().stable_hash(self.ws.root());
         util::short_hash(&hashable)
     }
 
     /// Returns the appropriate output directory for the specified package and
     /// target.
-    pub fn out_dir(&self, unit: &Unit<'a>) -> PathBuf {
+    pub fn out_dir(&self, unit: &Unit) -> PathBuf {
         if unit.mode.is_doc() {
             self.layout(unit.kind).doc().to_path_buf()
         } else if unit.mode.is_doc_test() {
@@ -191,7 +191,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     }
 
     /// Directory name to use for a package in the form `NAME-HASH`.
-    pub fn pkg_dir(&self, unit: &Unit<'a>) -> String {
+    pub fn pkg_dir(&self, unit: &Unit) -> String {
         let name = unit.pkg.package_id().name();
         match self.metas[unit] {
             Some(ref meta) => format!("{}-{}", name, meta),
@@ -211,24 +211,24 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
 
     /// Returns the directories where Rust crate dependencies are found for the
     /// specified unit.
-    pub fn deps_dir(&self, unit: &Unit<'_>) -> &Path {
+    pub fn deps_dir(&self, unit: &Unit) -> &Path {
         self.layout(unit.kind).deps()
     }
 
     /// Directory where the fingerprint for the given unit should go.
-    pub fn fingerprint_dir(&self, unit: &Unit<'a>) -> PathBuf {
+    pub fn fingerprint_dir(&self, unit: &Unit) -> PathBuf {
         let dir = self.pkg_dir(unit);
         self.layout(unit.kind).fingerprint().join(dir)
     }
 
     /// Path where compiler output is cached.
-    pub fn message_cache_path(&self, unit: &Unit<'a>) -> PathBuf {
+    pub fn message_cache_path(&self, unit: &Unit) -> PathBuf {
         self.fingerprint_dir(unit).join("output")
     }
 
     /// Returns the directory where a compiled build script is stored.
     /// `/path/to/target/{debug,release}/build/PKG-HASH`
-    pub fn build_script_dir(&self, unit: &Unit<'a>) -> PathBuf {
+    pub fn build_script_dir(&self, unit: &Unit) -> PathBuf {
         assert!(unit.target.is_custom_build());
         assert!(!unit.mode.is_run_custom_build());
         assert!(self.metas.contains_key(unit));
@@ -239,7 +239,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     /// Returns the directory where information about running a build script
     /// is stored.
     /// `/path/to/target/{debug,release}/build/PKG-HASH`
-    pub fn build_script_run_dir(&self, unit: &Unit<'a>) -> PathBuf {
+    pub fn build_script_run_dir(&self, unit: &Unit) -> PathBuf {
         assert!(unit.target.is_custom_build());
         assert!(unit.mode.is_run_custom_build());
         let dir = self.pkg_dir(unit);
@@ -248,12 +248,12 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
 
     /// Returns the "OUT_DIR" directory for running a build script.
     /// `/path/to/target/{debug,release}/build/PKG-HASH/out`
-    pub fn build_script_out_dir(&self, unit: &Unit<'a>) -> PathBuf {
+    pub fn build_script_out_dir(&self, unit: &Unit) -> PathBuf {
         self.build_script_run_dir(unit).join("out")
     }
 
     /// Returns the file stem for a given target/profile combo (with metadata).
-    pub fn file_stem(&self, unit: &Unit<'a>) -> String {
+    pub fn file_stem(&self, unit: &Unit) -> String {
         match self.metas[unit] {
             Some(ref metadata) => format!("{}-{}", unit.target.crate_name(), metadata),
             None => self.bin_stem(unit),
@@ -292,7 +292,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     /// Returns the filenames that the given unit will generate.
     pub(super) fn outputs(
         &self,
-        unit: &Unit<'a>,
+        unit: &Unit,
         bcx: &BuildContext<'a, 'cfg>,
     ) -> CargoResult<Arc<Vec<OutputFile>>> {
         self.outputs[unit]
@@ -301,7 +301,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     }
 
     /// Returns the bin filename for a given target, without extension and metadata.
-    fn bin_stem(&self, unit: &Unit<'_>) -> String {
+    fn bin_stem(&self, unit: &Unit) -> String {
         if unit.target.allows_dashes() {
             unit.target.name().to_string()
         } else {
@@ -322,7 +322,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     ///
     /// Returns an `Option` because in some cases we don't want to link
     /// (eg a dependent lib).
-    fn link_stem(&self, unit: &Unit<'a>) -> Option<(PathBuf, String)> {
+    fn link_stem(&self, unit: &Unit) -> Option<(PathBuf, String)> {
         let out_dir = self.out_dir(unit);
         let bin_stem = self.bin_stem(unit); // Stem without metadata.
         let file_stem = self.file_stem(unit); // Stem with metadata.
@@ -355,7 +355,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
 
     fn calc_outputs(
         &self,
-        unit: &Unit<'a>,
+        unit: &Unit,
         bcx: &BuildContext<'a, 'cfg>,
     ) -> CargoResult<Arc<Vec<OutputFile>>> {
         let ret = match unit.mode {
@@ -405,7 +405,7 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
 
     fn calc_outputs_rustc(
         &self,
-        unit: &Unit<'a>,
+        unit: &Unit,
         bcx: &BuildContext<'a, 'cfg>,
     ) -> CargoResult<Vec<OutputFile>> {
         let mut ret = Vec::new();
@@ -519,10 +519,10 @@ impl<'a, 'cfg: 'a> CompilationFiles<'a, 'cfg> {
     }
 }
 
-fn metadata_of<'a, 'cfg>(
-    unit: &Unit<'a>,
-    cx: &Context<'a, 'cfg>,
-    metas: &mut HashMap<Unit<'a>, Option<Metadata>>,
+fn metadata_of(
+    unit: &Unit,
+    cx: &Context<'_, '_>,
+    metas: &mut HashMap<Unit, Option<Metadata>>,
 ) -> Option<Metadata> {
     if !metas.contains_key(unit) {
         let meta = compute_metadata(unit, cx, metas);
@@ -534,10 +534,10 @@ fn metadata_of<'a, 'cfg>(
     metas[unit]
 }
 
-fn compute_metadata<'a, 'cfg>(
-    unit: &Unit<'a>,
-    cx: &Context<'a, 'cfg>,
-    metas: &mut HashMap<Unit<'a>, Option<Metadata>>,
+fn compute_metadata(
+    unit: &Unit,
+    cx: &Context<'_, '_>,
+    metas: &mut HashMap<Unit, Option<Metadata>>,
 ) -> Option<Metadata> {
     if unit.mode.is_doc_test() {
         // Doc tests do not have metadata.