Use listed dependency name for feature names

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

@@ -104,7 +104,7 @@ impl<'a, 'cfg> BuildContext<'a, 'cfg> {
 
         let crate_name = dep.target.crate_name();
         let mut names = deps.iter()
-            .map(|d| d.rename().unwrap_or(&crate_name));
+            .map(|d| d.rename().map(|s| s.as_str()).unwrap_or(&crate_name));
         let name = names.next().unwrap_or(&crate_name);
         for n in names {
             if n == name {

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

@@ -118,7 +118,7 @@ fn compute_deps<'a, 'cfg>(
 
             // If the dependency is optional, then we're only activating it
             // if the corresponding feature was activated
-            if dep.is_optional() && !bcx.resolve.features(id).contains(&*dep.name()) {
+            if dep.is_optional() && !bcx.resolve.features(id).contains(&*dep.name_in_toml()) {
                 return false;
             }
 

src/cargo/core/dependency.rs

@@ -28,7 +28,7 @@ struct Inner {
     specified_req: bool,
     kind: Kind,
     only_match_name: bool,
-    rename: Option<String>,
+    rename: Option<InternedString>,
 
     optional: bool,
     default_features: bool,
@@ -66,15 +66,15 @@ impl ser::Serialize for Dependency {
     {
         let string_features: Vec<_> = self.features().iter().map(|s| s.to_string()).collect();
         SerializedDependency {
-            name: &*self.name(),
+            name: &*self.package_name(),
             source: self.source_id(),
             req: self.version_req().to_string(),
             kind: self.kind(),
             optional: self.is_optional(),
             uses_default_features: self.uses_default_features(),
             features: &string_features,
             target: self.platform(),
-            rename: self.rename(),
+            rename: self.rename().map(|s| s.as_str()),
         }.serialize(s)
     }
 }
@@ -209,7 +209,49 @@ impl Dependency {
         &self.inner.req
     }
 
-    pub fn name(&self) -> InternedString {
+    /// This is the name of this `Dependency` as listed in `Cargo.toml`.
+    ///
+    /// Or in other words, this is what shows up in the `[dependencies]` section
+    /// on the left hand side. This is **not** the name of the package that's
+    /// being depended on as the dependency can be renamed. For that use
+    /// `package_name` below.
+    ///
+    /// Both of the dependencies below return `foo` for `name_in_toml`:
+    ///
+    /// ```toml
+    /// [dependencies]
+    /// foo = "0.1"
+    /// ```
+    ///
+    /// and ...
+    ///
+    /// ```toml
+    /// [dependencies]
+    /// foo = { version = "0.1", package = 'bar' }
+    /// ```
+    pub fn name_in_toml(&self) -> InternedString {
+        self.rename().unwrap_or(self.inner.name)
+    }
+
+    /// The name of the package that this `Dependency` depends on.
+    ///
+    /// Usually this is what's written on the left hand side of a dependencies
+    /// section, but it can also be renamed via the `package` key.
+    ///
+    /// Both of the dependencies below return `foo` for `package_name`:
+    ///
+    /// ```toml
+    /// [dependencies]
+    /// foo = "0.1"
+    /// ```
+    ///
+    /// and ...
+    ///
+    /// ```toml
+    /// [dependencies]
+    /// bar = { version = "0.1", package = 'foo' }
+    /// ```
+    pub fn package_name(&self) -> InternedString {
         self.inner.name
     }
 
@@ -240,8 +282,12 @@ impl Dependency {
         self.inner.platform.as_ref()
     }
 
-    pub fn rename(&self) -> Option<&str> {
-        self.inner.rename.as_ref().map(|s| &**s)
+    /// The renamed name of this dependency, if any.
+    ///
+    /// If the `package` key is used in `Cargo.toml` then this returns the same
+    /// value as `name_in_toml`.
+    pub fn rename(&self) -> Option<InternedString> {
+        self.inner.rename
     }
 
     pub fn set_kind(&mut self, kind: Kind) -> &mut Dependency {
@@ -286,7 +332,7 @@ impl Dependency {
     }
 
     pub fn set_rename(&mut self, rename: &str) -> &mut Dependency {
-        Rc::make_mut(&mut self.inner).rename = Some(rename.to_string());
+        Rc::make_mut(&mut self.inner).rename = Some(InternedString::new(rename));
         self
     }
 
@@ -296,7 +342,7 @@ impl Dependency {
         assert!(self.inner.req.matches(id.version()));
         trace!(
             "locking dep from `{}` with `{}` at {} to {}",
-            self.name(),
+            self.package_name(),
             self.version_req(),
             self.source_id(),
             id
@@ -347,7 +393,7 @@ impl Dependency {
 
     /// Returns true if the package (`sum`) can fulfill this dependency request.
     pub fn matches_ignoring_source(&self, id: &PackageId) -> bool {
-        self.name() == id.name() && self.version_req().matches(id.version())
+        self.package_name() == id.name() && self.version_req().matches(id.version())
     }
 
     /// Returns true if the package (`id`) can fulfill this dependency request.

src/cargo/core/registry.rs

@@ -197,7 +197,7 @@ impl<'cfg> PackageRegistry<'cfg> {
         // of summaries which should be the same length as `deps` above.
         let unlocked_summaries = deps.iter()
             .map(|dep| {
-                debug!("registring a patch for `{}` with `{}`", url, dep.name());
+                debug!("registring a patch for `{}` with `{}`", url, dep.package_name());
 
                 // Go straight to the source for resolving `dep`. Load it as we
                 // normally would and then ask it directly for the list of summaries
@@ -207,7 +207,7 @@ impl<'cfg> PackageRegistry<'cfg> {
                         format_err!(
                             "failed to load source for a dependency \
                              on `{}`",
-                            dep.name()
+                            dep.package_name()
                         )
                     })?;
 
@@ -223,22 +223,22 @@ impl<'cfg> PackageRegistry<'cfg> {
                         "patch for `{}` in `{}` did not resolve to any crates. If this is \
                          unexpected, you may wish to consult: \
                          https://github.com/rust-lang/cargo/issues/4678",
-                        dep.name(),
+                        dep.package_name(),
                         url
                     ),
                 };
                 if summaries.next().is_some() {
                     bail!(
                         "patch for `{}` in `{}` resolved to more than one candidate",
-                        dep.name(),
+                        dep.package_name(),
                         url
                     )
                 }
                 if summary.package_id().source_id().url() == url {
                     bail!(
                         "patch for `{}` in `{}` points to the same source, but \
                          patches must point to different sources",
-                        dep.name(),
+                        dep.package_name(),
                         url
                     );
                 }
@@ -306,7 +306,7 @@ impl<'cfg> PackageRegistry<'cfg> {
     fn query_overrides(&mut self, dep: &Dependency) -> CargoResult<Option<Summary>> {
         for s in self.overrides.iter() {
             let src = self.sources.get_mut(s).unwrap();
-            let dep = Dependency::new_override(&*dep.name(), s);
+            let dep = Dependency::new_override(&*dep.package_name(), s);
             let mut results = src.query_vec(&dep)?;
             if !results.is_empty() {
                 return Ok(Some(results.remove(0)));
@@ -369,21 +369,21 @@ http://doc.crates.io/specifying-dependencies.html#overriding-dependencies
                  modified to not match the previously resolved version\n\n\
                  {}",
                 override_summary.package_id().name(),
-                dep.name(),
+                dep.package_name(),
                 boilerplate
             );
             self.source_config.config().shell().warn(&msg)?;
             return Ok(());
         }
 
-        if let Some(id) = real_deps.get(0) {
+        if let Some(dep) = real_deps.get(0) {
             let msg = format!(
                 "\
                 path override for crate `{}` has altered the original list of
                 dependencies; the dependency on `{}` was removed\n\n
                 {}",
                 override_summary.package_id().name(),
-                id.name(),
+                dep.package_name(),
                 boilerplate
             );
             self.source_config.config().shell().warn(&msg)?;
@@ -439,7 +439,7 @@ impl<'cfg> Registry for PackageRegistry<'cfg> {
                          with `{}`, \
                          looking at sources",
                         patches.len(),
-                        dep.name(),
+                        dep.package_name(),
                         dep.source_id(),
                         dep.version_req()
                     );
@@ -451,7 +451,7 @@ impl<'cfg> Registry for PackageRegistry<'cfg> {
                         format_err!(
                             "failed to load source for a dependency \
                              on `{}`",
-                            dep.name()
+                            dep.package_name()
                         )
                     })?;
 
@@ -542,7 +542,7 @@ fn lock(locked: &LockedMap, patches: &HashMap<Url, Vec<PackageId>>, summary: Sum
         None => summary,
     };
     summary.map_dependencies(|dep| {
-        trace!("\t{}/{}/{}", dep.name(), dep.version_req(), dep.source_id());
+        trace!("\t{}/{}/{}", dep.package_name(), dep.version_req(), dep.source_id());
 
         // If we've got a known set of overrides for this summary, then
         // one of a few cases can arise:
@@ -578,7 +578,7 @@ fn lock(locked: &LockedMap, patches: &HashMap<Url, Vec<PackageId>>, summary: Sum
         // If anything does then we lock it to that and move on.
         let v = locked
             .get(dep.source_id())
-            .and_then(|map| map.get(&*dep.name()))
+            .and_then(|map| map.get(&*dep.package_name()))
             .and_then(|vec| vec.iter().find(|&&(ref id, _)| dep.matches_id(id)));
         if let Some(&(ref id, _)) = v {
             trace!("\tsecond hit on {}", id);
@@ -592,7 +592,7 @@ fn lock(locked: &LockedMap, patches: &HashMap<Url, Vec<PackageId>>, summary: Sum
         let v = patches.get(dep.source_id().url()).map(|vec| {
             let dep2 = dep.clone();
             let mut iter = vec.iter().filter(move |p| {
-                dep2.name() == p.name() && dep2.version_req().matches(p.version())
+                dep2.matches_ignoring_source(p)
             });
             (iter.next(), iter)
         });

src/cargo/core/resolver/conflict_cache.rs

@@ -81,7 +81,7 @@ impl ConflictCache {
             .entry(dep.clone())
             .or_insert_with(Vec::new);
         if !past.contains(con) {
-            trace!("{} adding a skip {:?}", dep.name(), con);
+            trace!("{} adding a skip {:?}", dep.package_name(), con);
             past.push(con.clone());
             for c in con.keys() {
                 self.dep_from_pid

src/cargo/core/resolver/context.rs

@@ -128,7 +128,7 @@ impl Context {
 
     pub fn prev_active(&self, dep: &Dependency) -> &[Summary] {
         self.activations
-            .get(&(dep.name(), dep.source_id().clone()))
+            .get(&(dep.package_name(), dep.source_id().clone()))
             .map(|v| &v[..])
             .unwrap_or(&[])
     }
@@ -178,27 +178,27 @@ impl Context {
         for dep in deps {
             // Skip optional dependencies, but not those enabled through a
             // feature
-            if dep.is_optional() && !reqs.deps.contains_key(&dep.name()) {
+            if dep.is_optional() && !reqs.deps.contains_key(&dep.name_in_toml()) {
                 continue;
             }
             // So we want this dependency. Move the features we want from
             // `feature_deps` to `ret` and register ourselves as using this
             // name.
-            let base = reqs.deps.get(&dep.name()).unwrap_or(&default_dep);
-            used_features.insert(dep.name());
+            let base = reqs.deps.get(&dep.name_in_toml()).unwrap_or(&default_dep);
+            used_features.insert(dep.name_in_toml());
             let always_required = !dep.is_optional()
                 && !s
                     .dependencies()
                     .iter()
-                    .any(|d| d.is_optional() && d.name() == dep.name());
+                    .any(|d| d.is_optional() && d.name_in_toml() == dep.name_in_toml());
             if always_required && base.0 {
                 self.warnings.push(format!(
                     "Package `{}` does not have feature `{}`. It has a required dependency \
                      with that name, but only optional dependencies can be used as features. \
                      This is currently a warning to ease the transition, but it will become an \
                      error in the future.",
                     s.package_id(),
-                    dep.name()
+                    dep.name_in_toml()
                 ));
             }
             let mut base = base.1.clone();
@@ -220,8 +220,8 @@ impl Context {
         let remaining = reqs
             .deps
             .keys()
-            .filter(|&s| !used_features.contains(s))
-            .map(|s| s.as_str())
+            .cloned()
+            .filter(|s| !used_features.contains(s))
             .collect::<Vec<_>>();
         if !remaining.is_empty() {
             let features = remaining.join(", ");
@@ -298,10 +298,10 @@ fn build_requirements<'a, 'b: 'a>(
             all_features: true, ..
         } => {
             for key in s.features().keys() {
-                reqs.require_feature(InternedString::new(&key))?;
+                reqs.require_feature(*key)?;
             }
             for dep in s.dependencies().iter().filter(|d| d.is_optional()) {
-                reqs.require_dependency(dep.name());
+                reqs.require_dependency(dep.name_in_toml());
             }
         }
         Method::Required {
@@ -389,7 +389,7 @@ impl<'r> Requirements<'r> {
         for fv in self
             .summary
             .features()
-            .get(&feat)
+            .get(feat.as_str())
             .expect("must be a valid feature")
         {
             match *fv {