auto merge of #485 : alexcrichton/cargo/fix-for-rustc-master, r=alexcrichton

bors · bors · commit 64156a39c449 · 2014-08-29T19:04:34.000Z
Extending #479 to use a `'static` shell instead of a `'a` shell.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/cargo/core/manifest.rs b/src/cargo/core/manifest.rs
@@ -1,5 +1,4 @@
 use std::hash;
-use std::result;
 use std::fmt::{mod, Show, Formatter};
 use semver::Version;
 use serialize::{Encoder,Encodable};
@@ -85,7 +84,7 @@ impl LibKind {
     }
 
     pub fn from_strs<S: Str>(strings: Vec<S>) -> CargoResult<Vec<LibKind>> {
-        result::collect(strings.iter().map(|s| LibKind::from_str(s.as_slice())))
+        strings.iter().map(|s| LibKind::from_str(s.as_slice())).collect()
     }
 
     pub fn crate_type(&self) -> &'static str {
diff --git a/src/cargo/core/registry.rs b/src/cargo/core/registry.rs
@@ -16,7 +16,7 @@ impl Registry for Vec<Summary> {
 }
 
 pub struct PackageRegistry<'a> {
-    sources: SourceMap,
+    sources: SourceMap<'a>,
     overrides: Vec<SourceId>,
     config: &'a mut Config<'a>
 }
@@ -53,7 +53,7 @@ impl<'a> PackageRegistry<'a> {
         Ok(ret)
     }
 
-    pub fn move_sources(self) -> SourceMap {
+    pub fn move_sources(self) -> SourceMap<'a> {
         self.sources
     }
 
diff --git a/src/cargo/core/resolver.rs b/src/cargo/core/resolver.rs
@@ -216,7 +216,7 @@ impl fmt::Show for Resolve {
     }
 }
 
-struct Context<'a, R> {
+struct Context<'a, R:'a> {
     registry: &'a mut R,
     resolve: Resolve,
 
diff --git a/src/cargo/core/shell.rs b/src/cargo/core/shell.rs
@@ -11,8 +11,8 @@ pub struct ShellConfig {
 }
 
 enum AdequateTerminal {
-    NoColor(Box<Writer>),
-    Color(Box<Terminal<Box<Writer>>>)
+    NoColor(Box<Writer+'static>),
+    Color(Box<Terminal<Box<Writer+'static>>+'static>)
 }
 
 pub struct Shell {
@@ -75,14 +75,14 @@ impl MultiShell {
 pub type ShellCallback<'a> = |&mut Shell|:'a -> IoResult<()>;
 
 impl Shell {
-    pub fn create(out: Box<Writer>, config: ShellConfig) -> Shell {
+    pub fn create(out: Box<Writer+'static>, config: ShellConfig) -> Shell {
         if config.tty && config.color {
-            let term: Option<term::TerminfoTerminal<Box<Writer>>> = Terminal::new(out);
+            let term: Option<term::TerminfoTerminal<Box<Writer+'static>>> = Terminal::new(out);
             term.map(|t| Shell {
-                terminal: Color(box t as Box<Terminal<Box<Writer>>>),
+                terminal: Color(box t as Box<Terminal<Box<Writer+'static>>>),
                 config: config
             }).unwrap_or_else(|| {
-                Shell { terminal: NoColor(box stderr() as Box<Writer>), config: config }
+                Shell { terminal: NoColor(box stderr() as Box<Writer+'static>), config: config }
             })
         } else {
             Shell { terminal: NoColor(out), config: config }
@@ -121,8 +121,8 @@ impl Shell {
     }
 }
 
-impl Terminal<Box<Writer>> for Shell {
-    fn new(out: Box<Writer>) -> Option<Shell> {
+impl Terminal<Box<Writer+'static>> for Shell {
+    fn new(out: Box<Writer+'static>) -> Option<Shell> {
         Some(Shell {
             terminal: NoColor(out),
             config: ShellConfig {
@@ -168,18 +168,18 @@ impl Terminal<Box<Writer>> for Shell {
         }
     }
 
-    fn unwrap(self) -> Box<Writer> {
+    fn unwrap(self) -> Box<Writer+'static> {
         fail!("Can't unwrap a Shell");
     }
 
-    fn get_ref<'a>(&'a self) -> &'a Box<Writer> {
+    fn get_ref<'b>(&'b self) -> &'b Box<Writer+'static> {
         match self.terminal {
             Color(ref c) => c.get_ref(),
             NoColor(ref w) => w
         }
     }
 
-    fn get_mut<'a>(&'a mut self) -> &'a mut Box<Writer> {
+    fn get_mut<'b>(&'b mut self) -> &'b mut Box<Writer+'static> {
         match self.terminal {
             Color(ref mut c) => c.get_mut(),
             NoColor(ref mut w) => w
diff --git a/src/cargo/core/source.rs b/src/cargo/core/source.rs
@@ -244,18 +244,18 @@ impl SourceId {
         }
     }
 
-    pub fn load(&self, config: &mut Config) -> Box<Source> {
+    pub fn load<'a>(&self, config: &'a mut Config) -> Box<Source+'a> {
         log!(5, "loading SourceId; {}", self);
         match self.kind {
-            GitKind(..) => box GitSource::new(self, config) as Box<Source>,
+            GitKind(..) => box GitSource::new(self, config) as Box<Source+'a>,
             PathKind => {
                 let path = match self.url.to_file_path() {
                     Ok(p) => p,
                     Err(()) => fail!("path sources cannot be remote"),
                 };
                 box PathSource::new(&path, self) as Box<Source>
             },
-            RegistryKind => box DummyRegistrySource::new(self) as Box<Source>,
+            RegistryKind => box DummyRegistrySource::new(self) as Box<Source+'a>,
         }
     }
 
@@ -267,17 +267,17 @@ impl SourceId {
     }
 }
 
-pub struct SourceMap {
-    map: HashMap<SourceId, Box<Source>>
+pub struct SourceMap<'a> {
+    map: HashMap<SourceId, Box<Source+'a>>
 }
 
-pub type Sources<'a> = Values<'a, SourceId, Box<Source>>;
-pub type SourcesMut<'a> = iter::Map<'static, (&'a SourceId, &'a mut Box<Source>),
-                                    &'a mut Source,
-                                    MutEntries<'a, SourceId, Box<Source>>>;
+pub type Sources<'a> = Values<'a, SourceId, Box<Source+'a>>;
+pub type SourcesMut<'a> = iter::Map<'static, (&'a SourceId, &'a mut Box<Source+'a>),
+                                    &'a mut Source+'a,
+                                    MutEntries<'a, SourceId, Box<Source+'a>>>;
 
-impl SourceMap {
-    pub fn new() -> SourceMap {
+impl<'a> SourceMap<'a> {
+    pub fn new() -> SourceMap<'a> {
         SourceMap {
             map: HashMap::new()
         }
@@ -287,54 +287,54 @@ impl SourceMap {
         self.map.contains_key(id)
     }
 
-    pub fn get(&self, id: &SourceId) -> Option<&Source> {
+    pub fn get(&self, id: &SourceId) -> Option<&Source+'a> {
         let source = self.map.find(id);
 
         source.map(|s| {
-            let s: &Source = *s;
+            let s: &Source+'a = *s;
             s
         })
     }
 
-    pub fn get_mut(&mut self, id: &SourceId) -> Option<&mut Source> {
+    pub fn get_mut(&mut self, id: &SourceId) -> Option<&mut Source+'a> {
         self.map.find_mut(id).map(|s| {
-            let s: &mut Source = *s;
+            let s: &mut Source+'a = *s;
             s
         })
     }
 
-    pub fn get_by_package_id(&self, pkg_id: &PackageId) -> Option<&Source> {
+    pub fn get_by_package_id(&self, pkg_id: &PackageId) -> Option<&Source+'a> {
         self.get(pkg_id.get_source_id())
     }
 
-    pub fn insert(&mut self, id: &SourceId, source: Box<Source>) {
+    pub fn insert(&mut self, id: &SourceId, source: Box<Source+'a>) {
         self.map.insert(id.clone(), source);
     }
 
     pub fn len(&self) -> uint {
         self.map.len()
     }
 
-    pub fn sources(&self) -> Sources {
+    pub fn sources(&'a self) -> Sources<'a> {
         self.map.values()
     }
 
-    pub fn sources_mut(&mut self) -> SourcesMut {
-        self.map.mut_iter().map(|(_, v)| { let s: &mut Source = *v; s })
+    pub fn sources_mut(&'a mut self) -> SourcesMut<'a> {
+        self.map.mut_iter().map(|(_, v)| { let s: &mut Source+'a = *v; s })
     }
 }
 
-pub struct SourceSet {
-    sources: Vec<Box<Source>>
+pub struct SourceSet<'a> {
+    sources: Vec<Box<Source+'a>>
 }
 
-impl SourceSet {
-    pub fn new(sources: Vec<Box<Source>>) -> SourceSet {
+impl<'a> SourceSet<'a> {
+    pub fn new(sources: Vec<Box<Source+'a>>) -> SourceSet<'a> {
         SourceSet { sources: sources }
     }
 }
 
-impl Registry for SourceSet {
+impl<'a> Registry for SourceSet<'a> {
     fn query(&mut self, name: &Dependency) -> CargoResult<Vec<Summary>> {
         let mut ret = Vec::new();
 
@@ -346,7 +346,7 @@ impl Registry for SourceSet {
     }
 }
 
-impl Source for SourceSet {
+impl<'a> Source for SourceSet<'a> {
     fn update(&mut self) -> CargoResult<()> {
         for source in self.sources.mut_iter() {
             try!(source.update());
diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
@@ -24,7 +24,6 @@
 
 use std::os;
 use std::collections::{HashMap, HashSet};
-use std::result;
 
 use core::registry::PackageRegistry;
 use core::{MultiShell, Source, SourceId, PackageSet, Target, PackageId};
@@ -147,9 +146,9 @@ fn source_ids_from_config(configs: &HashMap<String, config::ConfigValue>,
 
     // Make sure we don't override the local package, even if it's in the list
     // of override paths
-    result::collect(paths.iter().filter(|p| {
+    paths.iter().filter(|p| {
         cur_path != os::make_absolute(&Path::new(p.as_slice()))
-    }).map(|p| SourceId::for_path(&Path::new(p.as_slice()))))
+    }).map(|p| SourceId::for_path(&Path::new(p.as_slice()))).collect()
 }
 
 fn scrape_target_config(config: &mut Config,
diff --git a/src/cargo/ops/cargo_rustc/context.rs b/src/cargo/ops/cargo_rustc/context.rs
@@ -19,7 +19,7 @@ pub struct Context<'a, 'b> {
     pub rustc_version: String,
     pub config: &'b mut Config<'b>,
     pub resolve: &'a Resolve,
-    pub sources: &'a SourceMap,
+    pub sources: &'a SourceMap<'b>,
     pub compilation: Compilation,
 
     env: &'a str,
diff --git a/src/cargo/sources/git/source.rs b/src/cargo/sources/git/source.rs
@@ -12,7 +12,7 @@ use sources::git::utils::{GitReference, GitRemote, Master, Other, GitRevision};
 
 /* TODO: Refactor GitSource to delegate to a PathSource
  */
-pub struct GitSource<'a, 'b> {
+pub struct GitSource<'a, 'b:'a> {
     remote: GitRemote,
     reference: GitReference,
     db_path: Path,
@@ -195,7 +195,7 @@ impl<'a, 'b> Source for GitSource<'a, 'b> {
     }
 
     fn fingerprint(&self, _pkg: &Package) -> CargoResult<String> {
-        Ok(self.rev.get_ref().to_string())
+        Ok(self.rev.as_ref().unwrap().to_string())
     }
 }
 
diff --git a/src/cargo/util/toml.rs b/src/cargo/util/toml.rs
@@ -396,10 +396,10 @@ impl TomlManifest {
             None => inferred_test_targets(layout),
         };
 
-        let benches = if self.bench.is_none() || self.bench.get_ref().is_empty() {
+        let benches = if self.bench.is_none() || self.bench.as_ref().unwrap().is_empty() {
             inferred_bench_targets(layout)
         } else {
-            self.bench.get_ref().iter().map(|t| t.clone()).collect()
+            self.bench.as_ref().unwrap().iter().map(|t| t.clone()).collect()
         };
 
         // Get targets
diff --git a/tests/test_cargo_cross_compile.rs b/tests/test_cargo_cross_compile.rs
diff --git a/tests/test_shell.rs b/tests/test_shell.rs

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`use std::hash;`
`2`		`-use std::result;`
`3`	`2`	`use std::fmt::{mod, Show, Formatter};`
`4`	`3`	`use semver::Version;`
`5`	`4`	`use serialize::{Encoder,Encodable};`
`@@ -85,7 +84,7 @@ impl LibKind {`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`pub fn from_strs<S: Str>(strings: Vec<S>) -> CargoResult<Vec<LibKind>> {`
`88`		`- result::collect(strings.iter().map(\|s\| LibKind::from_str(s.as_slice())))`
	`87`	`+ strings.iter().map(\|s\| LibKind::from_str(s.as_slice())).collect()`
`89`	`88`	`}`
`90`	`89`
`91`	`90`	`pub fn crate_type(&self) -> &'static str {`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ impl Registry for Vec<Summary> {`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`pub struct PackageRegistry<'a> {`
`19`		`- sources: SourceMap,`
	`19`	`+ sources: SourceMap<'a>,`
`20`	`20`	`overrides: Vec<SourceId>,`
`21`	`21`	`config: &'a mut Config<'a>`
`22`	`22`	`}`
`@@ -53,7 +53,7 @@ impl<'a> PackageRegistry<'a> {`
`53`	`53`	`Ok(ret)`
`54`	`54`	`}`
`55`	`55`
`56`		`- pub fn move_sources(self) -> SourceMap {`
	`56`	`+ pub fn move_sources(self) -> SourceMap<'a> {`
`57`	`57`	`self.sources`
`58`	`58`	`}`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -216,7 +216,7 @@ impl fmt::Show for Resolve {`
`216`	`216`	`}`
`217`	`217`	`}`
`218`	`218`
`219`		`-struct Context<'a, R> {`
	`219`	`+struct Context<'a, R:'a> {`
`220`	`220`	`registry: &'a mut R,`
`221`	`221`	`resolve: Resolve,`
`222`	`222`
Original file line number	Diff line number	Diff line change
`@@ -244,18 +244,18 @@ impl SourceId {`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`247`		`- pub fn load(&self, config: &mut Config) -> Box<Source> {`
	`247`	`+ pub fn load<'a>(&self, config: &'a mut Config) -> Box<Source+'a> {`
`248`	`248`	`log!(5, "loading SourceId; {}", self);`
`249`	`249`	`match self.kind {`
`250`		`- GitKind(..) => box GitSource::new(self, config) as Box<Source>,`
	`250`	`+ GitKind(..) => box GitSource::new(self, config) as Box<Source+'a>,`
`251`	`251`	`PathKind => {`
`252`	`252`	`let path = match self.url.to_file_path() {`
`253`	`253`	`Ok(p) => p,`
`254`	`254`	`Err(()) => fail!("path sources cannot be remote"),`
`255`	`255`	`};`
`256`	`256`	`box PathSource::new(&path, self) as Box<Source>`
`257`	`257`	`},`
`258`		`- RegistryKind => box DummyRegistrySource::new(self) as Box<Source>,`
	`258`	`+ RegistryKind => box DummyRegistrySource::new(self) as Box<Source+'a>,`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`
`@@ -267,17 +267,17 @@ impl SourceId {`
`267`	`267`	`}`
`268`	`268`	`}`
`269`	`269`
`270`		`-pub struct SourceMap {`
`271`		`- map: HashMap<SourceId, Box<Source>>`
	`270`	`+pub struct SourceMap<'a> {`
	`271`	`+ map: HashMap<SourceId, Box<Source+'a>>`
`272`	`272`	`}`
`273`	`273`
`274`		`-pub type Sources<'a> = Values<'a, SourceId, Box<Source>>;`
`275`		`-pub type SourcesMut<'a> = iter::Map<'static, (&'a SourceId, &'a mut Box<Source>),`
`276`		`- &'a mut Source,`
`277`		`- MutEntries<'a, SourceId, Box<Source>>>;`
	`274`	`+pub type Sources<'a> = Values<'a, SourceId, Box<Source+'a>>;`
	`275`	`+pub type SourcesMut<'a> = iter::Map<'static, (&'a SourceId, &'a mut Box<Source+'a>),`
	`276`	`+ &'a mut Source+'a,`
	`277`	`+ MutEntries<'a, SourceId, Box<Source+'a>>>;`
`278`	`278`
`279`		`-impl SourceMap {`
`280`		`- pub fn new() -> SourceMap {`
	`279`	`+impl<'a> SourceMap<'a> {`
	`280`	`+ pub fn new() -> SourceMap<'a> {`
`281`	`281`	`SourceMap {`
`282`	`282`	`map: HashMap::new()`
`283`	`283`	`}`
`@@ -287,54 +287,54 @@ impl SourceMap {`
`287`	`287`	`self.map.contains_key(id)`
`288`	`288`	`}`
`289`	`289`
`290`		`- pub fn get(&self, id: &SourceId) -> Option<&Source> {`
	`290`	`+ pub fn get(&self, id: &SourceId) -> Option<&Source+'a> {`
`291`	`291`	`let source = self.map.find(id);`
`292`	`292`
`293`	`293`	`source.map(\|s\| {`
`294`		`- let s: &Source = *s;`
	`294`	`+ let s: &Source+'a = *s;`
`295`	`295`	`s`
`296`	`296`	`})`
`297`	`297`	`}`
`298`	`298`
`299`		`- pub fn get_mut(&mut self, id: &SourceId) -> Option<&mut Source> {`
	`299`	`+ pub fn get_mut(&mut self, id: &SourceId) -> Option<&mut Source+'a> {`
`300`	`300`	`self.map.find_mut(id).map(\|s\| {`
`301`		`- let s: &mut Source = *s;`
	`301`	`+ let s: &mut Source+'a = *s;`
`302`	`302`	`s`
`303`	`303`	`})`
`304`	`304`	`}`
`305`	`305`
`306`		`- pub fn get_by_package_id(&self, pkg_id: &PackageId) -> Option<&Source> {`
	`306`	`+ pub fn get_by_package_id(&self, pkg_id: &PackageId) -> Option<&Source+'a> {`
`307`	`307`	`self.get(pkg_id.get_source_id())`
`308`	`308`	`}`
`309`	`309`
`310`		`- pub fn insert(&mut self, id: &SourceId, source: Box<Source>) {`
	`310`	`+ pub fn insert(&mut self, id: &SourceId, source: Box<Source+'a>) {`
`311`	`311`	`self.map.insert(id.clone(), source);`
`312`	`312`	`}`
`313`	`313`
`314`	`314`	`pub fn len(&self) -> uint {`
`315`	`315`	`self.map.len()`
`316`	`316`	`}`
`317`	`317`
`318`		`- pub fn sources(&self) -> Sources {`
	`318`	`+ pub fn sources(&'a self) -> Sources<'a> {`
`319`	`319`	`self.map.values()`
`320`	`320`	`}`
`321`	`321`
`322`		`- pub fn sources_mut(&mut self) -> SourcesMut {`
`323`		`- self.map.mut_iter().map(\|(_, v)\| { let s: &mut Source = *v; s })`
	`322`	`+ pub fn sources_mut(&'a mut self) -> SourcesMut<'a> {`
	`323`	`+ self.map.mut_iter().map(\|(_, v)\| { let s: &mut Source+'a = *v; s })`
`324`	`324`	`}`
`325`	`325`	`}`
`326`	`326`
`327`		`-pub struct SourceSet {`
`328`		`- sources: Vec<Box<Source>>`
	`327`	`+pub struct SourceSet<'a> {`
	`328`	`+ sources: Vec<Box<Source+'a>>`
`329`	`329`	`}`
`330`	`330`
`331`		`-impl SourceSet {`
`332`		`- pub fn new(sources: Vec<Box<Source>>) -> SourceSet {`
	`331`	`+impl<'a> SourceSet<'a> {`
	`332`	`+ pub fn new(sources: Vec<Box<Source+'a>>) -> SourceSet<'a> {`
`333`	`333`	`SourceSet { sources: sources }`
`334`	`334`	`}`
`335`	`335`	`}`
`336`	`336`
`337`		`-impl Registry for SourceSet {`
	`337`	`+impl<'a> Registry for SourceSet<'a> {`
`338`	`338`	`fn query(&mut self, name: &Dependency) -> CargoResult<Vec<Summary>> {`
`339`	`339`	`let mut ret = Vec::new();`
`340`	`340`
`@@ -346,7 +346,7 @@ impl Registry for SourceSet {`
`346`	`346`	`}`
`347`	`347`	`}`
`348`	`348`
`349`		`-impl Source for SourceSet {`
	`349`	`+impl<'a> Source for SourceSet<'a> {`
`350`	`350`	`fn update(&mut self) -> CargoResult<()> {`
`351`	`351`	`for source in self.sources.mut_iter() {`
`352`	`352`	`try!(source.update());`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ use sources::git::utils::{GitReference, GitRemote, Master, Other, GitRevision};`
`12`	`12`
`13`	`13`	`/* TODO: Refactor GitSource to delegate to a PathSource`
`14`	`14`	`*/`
`15`		`-pub struct GitSource<'a, 'b> {`
	`15`	`+pub struct GitSource<'a, 'b:'a> {`
`16`	`16`	`remote: GitRemote,`
`17`	`17`	`reference: GitReference,`
`18`	`18`	`db_path: Path,`
`@@ -195,7 +195,7 @@ impl<'a, 'b> Source for GitSource<'a, 'b> {`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`fn fingerprint(&self, _pkg: &Package) -> CargoResult<String> {`
`198`		`- Ok(self.rev.get_ref().to_string())`
	`198`	`+ Ok(self.rev.as_ref().unwrap().to_string())`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`