pub unsafe fn resolve(what: ResolveWhat<'_>, cb: &mut dyn FnMut(&super::Symbol))                 });             }         }-+        if let Some((object_cx, object_addr)) = cx.object.search_object_map(addr as u64) {

 impl<'a> Object<'a> {         let (sym, _addr) = self.syms.get(i)?;         Some(sym)     }++    /// Try to load a context for an object file.+    ///+    /// If dsymutil was not run, then the DWARF may be found in the source object files.+    pub(super) fn search_object_map<'b>(&'b mut self, addr: u64) -> Option<(&Context<'b>, u64)> {+        // `object_map` contains a map from addresses to symbols and object paths.+        // Look up the address and get a mapping for the object.+        let object_map = self.object_map.as_ref()?;+        let symbol = object_map.get(addr)?;+        let object_index = symbol.object_index();+        let mapping = self.object_mappings.get_mut(object_index)?;+        if mapping.is_none() {+            // No cached mapping, so create it.+            *mapping = Some(object_mapping(object_map.objects().get(object_index)?));+        }+        let cx: &'b Context<'static> = &mapping.as_ref()?.as_ref()?.cx;+        // Don't leak the `'static` lifetime, make sure it's scoped to just ourselves.+        let cx = unsafe { core::mem::transmute::<&'b Context<'static>, &'b Context<'b>>(cx) };++        // We must translate the address in order to be able to look it up+        // in the DWARF in the object file.+        let object_symbol = cx.object.syms.iter().find(|sym| sym.0 == symbol.name())?;+        let object_addr = addr+            .wrapping_sub(symbol.address())+            .wrapping_add(object_symbol.1);+        Some((cx, object_addr))+    }+}++fn object_mapping(path: &[u8]) -> Option<Mapping> {+    use super::mystd::ffi::OsStr;+    use super::mystd::os::unix::prelude::*;++    // `N_OSO` symbol names can be either `/path/to/object.o` or `/path/to/archive.a(object.o)`.+    if let Some((archive_path, member_name)) = split_archive_path(path) {+        let map = super::mmap(Path::new(OsStr::from_bytes(archive_path)))?;+        let archive = object::read::archive::ArchiveFile::parse(&map).ok()?;+        for member in archive.members() {+            let member = member.ok()?;+            if member.name() == member_name {+                let (macho, data) = find_header(Bytes(member.data()))?;+                let endian = macho.endian().ok()?;+                let object = Object::parse(macho, endian, data)?;+                let stash = Stash::new();+                let inner = super::cx(&stash, object)?;+                return Some(mk!(Mapping { map, inner, stash }));

 pub struct Object<'a> {     data: Bytes<'a>,     dwarf: Option<&'a [MachSection]>,     syms: Vec<(&'a [u8], u64)>,+    object_map: Option<object::ObjectMap<'a>>,

 pub struct Object<'a> {     data: Bytes<'a>,     dwarf: Option<&'a [MachSection]>,     syms: Vec<(&'a [u8], u64)>,+    object_map: Option<object::ObjectMap<'a>>,+    object_mappings: Vec<Option<Option<Mapping>>>,

 impl<'a> Object<'a> {         let (sym, _addr) = self.syms.get(i)?;         Some(sym)     }++    /// Try to load a context for an object file.+    ///+    /// If dsymutil was not run, then the DWARF may be found in the source object files.+    pub(super) fn search_object_map<'b>(&'b mut self, addr: u64) -> Option<(&Context<'b>, u64)> {+        // `object_map` contains a map from addresses to symbols and object paths.+        // Look up the address and get a mapping for the object.+        let object_map = self.object_map.as_ref()?;+        let symbol = object_map.get(addr)?;+        let object_index = symbol.object_index();+        let mapping = self.object_mappings.get_mut(object_index)?;+        if mapping.is_none() {+            // No cached mapping, so create it.+            *mapping = Some(object_mapping(object_map.objects().get(object_index)?));+        }+        let cx: &'b Context<'static> = &mapping.as_ref()?.as_ref()?.cx;+        // Don't leak the `'static` lifetime, make sure it's scoped to just ourselves.+        let cx = unsafe { core::mem::transmute::<&'b Context<'static>, &'b Context<'b>>(cx) };++        // We must translate the address in order to be able to look it up+        // in the DWARF in the object file.+        let object_symbol = cx.object.syms.iter().find(|sym| sym.0 == symbol.name())?;+        let object_addr = addr+            .wrapping_sub(symbol.address())+            .wrapping_add(object_symbol.1);+        Some((cx, object_addr))+    }+}++fn object_mapping(path: &[u8]) -> Option<Mapping> {+    use super::mystd::ffi::OsStr;+    use super::mystd::os::unix::prelude::*;++    // `N_OSO` symbol names can be either `/path/to/object.o` or `/path/to/archive.a(object.o)`.+    if let Some((archive_path, member_name)) = split_archive_path(path) {+        let map = super::mmap(Path::new(OsStr::from_bytes(archive_path)))?;+        let archive = object::read::archive::ArchiveFile::parse(&map).ok()?;+        for member in archive.members() {+            let member = member.ok()?;+            if member.name() == member_name {+                let (macho, data) = find_header(Bytes(member.data()))?;+                let endian = macho.endian().ok()?;+                let object = Object::parse(macho, endian, data)?;+                let stash = Stash::new();+                let inner = super::cx(&stash, object)?;+                return Some(mk!(Mapping { map, inner, stash }));+            }+        }+        None+    } else {+        let map = super::mmap(Path::new(OsStr::from_bytes(path)))?;+        let (macho, data) = find_header(Bytes(&map))?;+        let endian = macho.endian().ok()?;+        let object = Object::parse(macho, endian, data)?;+        let stash = Stash::new();+        let inner = super::cx(&stash, object)?;+        Some(mk!(Mapping { map, inner, stash }))+    }

 where             .push(dep);     } -    let mut map = BTreeMap::new();-    for (feature, list) in features.iter() {-        // If namespaced features is active and the key is the same as that of an-        // optional dependency, that dependency must be included in the values.-        // Thus, if a `feature` is found that has the same name as a dependency, we-        // (a) bail out if the dependency is non-optional, and (b) we track if the-        // feature requirements include the dependency `crate:feature` in the list.-        // This is done with the `dependency_found` variable, which can only be-        // false if features are namespaced and the current feature key is the same-        // as the name of an optional dependency. If so, it gets set to true during-        // iteration over the list if the dependency is found in the list.-        let mut dependency_found = if namespaced {-            match dep_map.get(feature.borrow()) {-                Some(dep_data) => {-                    if !dep_data.iter().any(|d| d.is_optional()) {-                        anyhow::bail!(-                            "Feature `{}` includes the dependency of the same name, but this is \-                             left implicit in the features included by this feature.\n\-                             Additionally, the dependency must be marked as optional to be \-                             included in the feature definition.\n\-                             Consider adding `crate:{}` to this feature's requirements \-                             and marking the dependency as `optional = true`",-                            feature,-                            feature-                        )-                    } else {-                        false-                    }-                }-                None => true,-            }-        } else {-            true+    let mut map: FeatureMap = features+        .iter()+        .map(|(feature, list)| {+            let fvs: Vec<_> = list+                .iter()+                .map(|feat_value| FeatureValue::new(*feat_value))+                .collect();+            (*feature, fvs)+        })+        .collect();+    let has_namespaced_features = map.values().flatten().any(|fv| fv.is_explicit_crate());++    // Add implicit features for optional dependencies if they weren't+    // explicitly listed anywhere.+    let explicitly_listed: HashSet<_> = map+        .values()+        .flatten()+        .filter_map(|fv| match fv {+            Crate { dep_name }+            | CrateFeature {+                dep_name,+                explicit: true,+                ..+            } => Some(*dep_name),+            _ => None,+        })+        .collect();+    for dep in dependencies {+        if !dep.is_optional() {+            continue;+        }+        let dep_name_in_toml = dep.name_in_toml();+        if features.contains_key(&dep_name_in_toml) || explicitly_listed.contains(&dep_name_in_toml)+        {+            continue;+        }+        let fv = Crate {+            dep_name: dep_name_in_toml,         };+        map.insert(dep_name_in_toml, vec![fv]);+    } -        let mut values = vec![];-        for dep in list {-            let val = FeatureValue::build(-                InternedString::new(dep.as_ref()),-                |fs| features.contains_key(fs.as_str()),-                namespaced,+    // Validate features are listed properly.+    for (feature, fvs) in &map {+        if feature.starts_with("crate:") {+            bail!(+                "feature named `{}` is not allowed to start with `crate:`",+                feature             );-+        }+        for fv in fvs {             // Find data for the referenced dependency...             let dep_data = {-                match val {-                    Feature(ref dep_name) | Crate(ref dep_name) | CrateFeature(ref dep_name, _) => {-                        dep_map.get(dep_name.as_str())+                match fv {+                    Feature(dep_name) | Crate { dep_name, .. } | CrateFeature { dep_name, .. } => {+                        dep_map.get(dep_name)                     }                 }             };             let is_optional_dep = dep_data                 .iter()                 .flat_map(|d| d.iter())                 .any(|d| d.is_optional());-            if let FeatureValue::Crate(ref dep_name) = val {-                // If we have a dependency value, check if this is the dependency named-                // the same as the feature that we were looking for.-                if !dependency_found && feature.borrow() == dep_name.as_str() {-                    dependency_found = true;-                }-            }--            match (&val, dep_data.is_some(), is_optional_dep) {-                // The value is a feature. If features are namespaced, this just means-                // it's not prefixed with `crate:`, so we have to check whether the-                // feature actually exist. If the feature is not defined *and* an optional-                // dependency of the same name exists, the feature is defined implicitly-                // here by adding it to the feature map, pointing to the dependency.-                // If features are not namespaced, it's been validated as a feature already-                // while instantiating the `FeatureValue` in `FeatureValue::build()`, so-                // we don't have to do so here.-                (&Feature(feat), _, true) => {-                    if namespaced && !features.contains_key(&*feat) {-                        map.insert(feat, vec![FeatureValue::Crate(feat)]);-                    }-                }-                // If features are namespaced and the value is not defined as a feature-                // and there is no optional dependency of the same name, error out.-                // If features are not namespaced, there must be an existing feature-                // here (checked by `FeatureValue::build()`), so it will always be defined.-                (&Feature(feat), dep_exists, false) => {-                    if namespaced && !features.contains_key(&*feat) {-                        if dep_exists {-                            anyhow::bail!(-                                "Feature `{}` includes `{}` which is not defined as a feature.\n\-                                 A non-optional dependency of the same name is defined; consider \-                                 adding `optional = true` to its definition",+            let is_any_dep = dep_data.is_some();+            match fv {+                Feature(f) => {+                    if !features.contains_key(f) {+                        if !is_any_dep {+                            bail!(+                                "feature `{}` includes `{}` which is neither a dependency \+                                 nor another feature",                                 feature,-                                feat-                            )+                                fv+                            );+                        }+                        if is_optional_dep {+                            if !map.contains_key(f) {+                                bail!(+                                    "feature `{}` includes `{}`, but `{}` is an \+                                     optional dependency without an implicit feature\n\+                                     Use `crate:{}` to enable the dependency.",+                                    feature,+                                    fv,+                                    f,+                                    f+                                );+                            }                         } else {-                            anyhow::bail!(-                                "Feature `{}` includes `{}` which is not defined as a feature",-                                feature,-                                feat-                            )+                            bail!("feature `{}` includes `{}`, but `{}` is not an optional dependency\n\+                                A non-optional dependency of the same name is defined; \+                                consider adding `optional = true` to its definition.",+                                feature, fv, f);                         }                     }                 }-                // The value is a dependency. If features are namespaced, it is explicitly-                // tagged as such (`crate:value`). If features are not namespaced, any value-                // not recognized as a feature is pegged as a `Crate`. Here we handle the case-                // where the dependency exists but is non-optional. It branches on namespaced-                // just to provide the correct string for the crate dependency in the error.-                (&Crate(ref dep), true, false) => {-                    if namespaced {-                        anyhow::bail!(-                            "Feature `{}` includes `crate:{}` which is not an \-                             optional dependency.\nConsider adding \-                             `optional = true` to the dependency",+                Crate { dep_name } => {+                    if !is_any_dep {+                        bail!(+                            "feature `{}` includes `{}`, but `{}` is not listed as a dependency",                             feature,-                            dep-                        )-                    } else {-                        anyhow::bail!(-                            "Feature `{}` depends on `{}` which is not an \-                             optional dependency.\nConsider adding \-                             `optional = true` to the dependency",+                            fv,+                            dep_name+                        );+                    }+                    if !is_optional_dep {+                        bail!(+                            "feature `{}` includes `{}`, but `{}` is not an optional dependency\n\+                             A non-optional dependency of the same name is defined; \+                             consider adding `optional = true` to its definition.",                             feature,-                            dep-                        )+                            fv,+                            dep_name+                        );                     }                 }-                // If namespaced, the value was tagged as a dependency; if not namespaced,-                // this could be anything not defined as a feature. This handles the case-                // where no such dependency is actually defined; again, the branch on-                // namespaced here is just to provide the correct string in the error.-                (&Crate(ref dep), false, _) => {-                    if namespaced {-                        anyhow::bail!(-                            "Feature `{}` includes `crate:{}` which is not a known \-                             dependency",-                            feature,-                            dep-                        )-                    } else {-                        anyhow::bail!(-                            "Feature `{}` includes `{}` which is neither a dependency nor \-                             another feature",+                CrateFeature { dep_name, .. } => {+                    // Validation of the feature name will be performed in the resolver.+                    if !is_any_dep {+                        bail!(+                            "feature `{}` includes `{}`, but `{}` is not a dependency",                             feature,-                            dep-                        )+                            fv,+                            dep_name+                        );                     }                 }-                (&Crate(_), true, true) => {}-                // If the value is a feature for one of the dependencies, bail out if no such-                // dependency is actually defined in the manifest.-                (&CrateFeature(ref dep, _), false, _) => anyhow::bail!(-                    "Feature `{}` requires a feature of `{}` which is not a \-                     dependency",-                    feature,-                    dep-                ),-                (&CrateFeature(_, _), true, _) => {}             }-            values.push(val);-        }--        if !dependency_found {-            // If we have not found the dependency of the same-named feature, we should-            // bail here.-            anyhow::bail!(-                "Feature `{}` includes the optional dependency of the \-                 same name, but this is left implicit in the features \-                 included by this feature.\nConsider adding \-                 `crate:{}` to this feature's requirements.",-                feature,-                feature-            )         }+    } -        map.insert(InternedString::new(feature.borrow()), values);+    // Make sure every optional dep is mentioned at least once.+    let used: HashSet<_> = map+        .values()+        .flatten()+        .filter_map(|fv| match fv {+            Crate { dep_name } | CrateFeature { dep_name, .. } => Some(dep_name),+            _ => None,+        })+        .collect();+    if let Some(dep) = dependencies+        .iter()+        .find(|dep| dep.is_optional() && !used.contains(&dep.name_in_toml()))+    {+        bail!(+            "optional dependency `{}` is not included in any feature\n\+            Make sure that `crate:{}` is included in one of features in the [features] table.",+            dep.name_in_toml(),+            dep.name_in_toml(),+        );     }-    Ok(map)++    Ok((map, has_namespaced_features)) } -/// FeatureValue represents the types of dependencies a feature can have:-///-/// * Another feature-/// * An optional dependency-/// * A feature in a dependency-///-/// The selection between these 3 things happens as part of the construction of the FeatureValue.+/// FeatureValue represents the types of dependencies a feature can have. #[derive(Clone, Debug)] pub enum FeatureValue {+    /// A feature enabling another feature.     Feature(InternedString),-    Crate(InternedString),-    CrateFeature(InternedString, InternedString),+    /// A feature enabling a dependency with `crate:dep_name` syntax.+    Crate { dep_name: InternedString },+    /// A feature enabling a feature on a dependency with `crate_name/feat_name` syntax.+    CrateFeature {+        dep_name: InternedString,+        dep_feature: InternedString,+        /// If this is true, then the feature used the `crate:` prefix, which+        /// prevents enabling the feature named `dep_name`.+        explicit: bool,

 where             .push(dep);     } -    let mut map = BTreeMap::new();-    for (feature, list) in features.iter() {-        // If namespaced features is active and the key is the same as that of an-        // optional dependency, that dependency must be included in the values.-        // Thus, if a `feature` is found that has the same name as a dependency, we-        // (a) bail out if the dependency is non-optional, and (b) we track if the-        // feature requirements include the dependency `crate:feature` in the list.-        // This is done with the `dependency_found` variable, which can only be-        // false if features are namespaced and the current feature key is the same-        // as the name of an optional dependency. If so, it gets set to true during-        // iteration over the list if the dependency is found in the list.-        let mut dependency_found = if namespaced {-            match dep_map.get(feature.borrow()) {-                Some(dep_data) => {-                    if !dep_data.iter().any(|d| d.is_optional()) {-                        anyhow::bail!(-                            "Feature `{}` includes the dependency of the same name, but this is \-                             left implicit in the features included by this feature.\n\-                             Additionally, the dependency must be marked as optional to be \-                             included in the feature definition.\n\-                             Consider adding `crate:{}` to this feature's requirements \-                             and marking the dependency as `optional = true`",-                            feature,-                            feature-                        )-                    } else {-                        false-                    }-                }-                None => true,-            }-        } else {-            true+    let mut map: FeatureMap = features+        .iter()+        .map(|(feature, list)| {+            let fvs: Vec<_> = list+                .iter()+                .map(|feat_value| FeatureValue::new(*feat_value))+                .collect();+            (*feature, fvs)+        })+        .collect();+    let has_namespaced_features = map.values().flatten().any(|fv| fv.is_explicit_crate());++    // Add implicit features for optional dependencies if they weren't+    // explicitly listed anywhere.+    let explicitly_listed: HashSet<_> = map+        .values()+        .flatten()+        .filter_map(|fv| match fv {+            Crate { dep_name }+            | CrateFeature {+                dep_name,+                explicit: true,+                ..+            } => Some(*dep_name),+            _ => None,+        })+        .collect();+    for dep in dependencies {+        if !dep.is_optional() {+            continue;+        }+        let dep_name_in_toml = dep.name_in_toml();+        if features.contains_key(&dep_name_in_toml) || explicitly_listed.contains(&dep_name_in_toml)+        {+            continue;+        }+        let fv = Crate {+            dep_name: dep_name_in_toml,         };+        map.insert(dep_name_in_toml, vec![fv]);+    } -        let mut values = vec![];-        for dep in list {-            let val = FeatureValue::build(-                InternedString::new(dep.as_ref()),-                |fs| features.contains_key(fs.as_str()),-                namespaced,+    // Validate features are listed properly.+    for (feature, fvs) in &map {+        if feature.starts_with("crate:") {+            bail!(+                "feature named `{}` is not allowed to start with `crate:`",+                feature             );-+        }+        for fv in fvs {             // Find data for the referenced dependency...             let dep_data = {-                match val {-                    Feature(ref dep_name) | Crate(ref dep_name) | CrateFeature(ref dep_name, _) => {-                        dep_map.get(dep_name.as_str())+                match fv {+                    Feature(dep_name) | Crate { dep_name, .. } | CrateFeature { dep_name, .. } => {+                        dep_map.get(dep_name)                     }                 }             };             let is_optional_dep = dep_data                 .iter()                 .flat_map(|d| d.iter())                 .any(|d| d.is_optional());-            if let FeatureValue::Crate(ref dep_name) = val {-                // If we have a dependency value, check if this is the dependency named-                // the same as the feature that we were looking for.-                if !dependency_found && feature.borrow() == dep_name.as_str() {-                    dependency_found = true;-                }-            }--            match (&val, dep_data.is_some(), is_optional_dep) {-                // The value is a feature. If features are namespaced, this just means-                // it's not prefixed with `crate:`, so we have to check whether the-                // feature actually exist. If the feature is not defined *and* an optional-                // dependency of the same name exists, the feature is defined implicitly-                // here by adding it to the feature map, pointing to the dependency.-                // If features are not namespaced, it's been validated as a feature already-                // while instantiating the `FeatureValue` in `FeatureValue::build()`, so-                // we don't have to do so here.-                (&Feature(feat), _, true) => {-                    if namespaced && !features.contains_key(&*feat) {-                        map.insert(feat, vec![FeatureValue::Crate(feat)]);-                    }-                }-                // If features are namespaced and the value is not defined as a feature-                // and there is no optional dependency of the same name, error out.-                // If features are not namespaced, there must be an existing feature-                // here (checked by `FeatureValue::build()`), so it will always be defined.-                (&Feature(feat), dep_exists, false) => {-                    if namespaced && !features.contains_key(&*feat) {-                        if dep_exists {-                            anyhow::bail!(-                                "Feature `{}` includes `{}` which is not defined as a feature.\n\-                                 A non-optional dependency of the same name is defined; consider \-                                 adding `optional = true` to its definition",+            let is_any_dep = dep_data.is_some();+            match fv {+                Feature(f) => {+                    if !features.contains_key(f) {+                        if !is_any_dep {+                            bail!(+                                "feature `{}` includes `{}` which is neither a dependency \+                                 nor another feature",                                 feature,-                                feat-                            )+                                fv+                            );+                        }+                        if is_optional_dep {+                            if !map.contains_key(f) {+                                bail!(+                                    "feature `{}` includes `{}`, but `{}` is an \+                                     optional dependency without an implicit feature\n\+                                     Use `crate:{}` to enable the dependency.",+                                    feature,+                                    fv,+                                    f,+                                    f+                                );+                            }                         } else {-                            anyhow::bail!(-                                "Feature `{}` includes `{}` which is not defined as a feature",-                                feature,-                                feat-                            )+                            bail!("feature `{}` includes `{}`, but `{}` is not an optional dependency\n\+                                A non-optional dependency of the same name is defined; \+                                consider adding `optional = true` to its definition.",+                                feature, fv, f);                         }                     }                 }-                // The value is a dependency. If features are namespaced, it is explicitly-                // tagged as such (`crate:value`). If features are not namespaced, any value-                // not recognized as a feature is pegged as a `Crate`. Here we handle the case-                // where the dependency exists but is non-optional. It branches on namespaced-                // just to provide the correct string for the crate dependency in the error.-                (&Crate(ref dep), true, false) => {-                    if namespaced {-                        anyhow::bail!(-                            "Feature `{}` includes `crate:{}` which is not an \-                             optional dependency.\nConsider adding \-                             `optional = true` to the dependency",+                Crate { dep_name } => {+                    if !is_any_dep {+                        bail!(+                            "feature `{}` includes `{}`, but `{}` is not listed as a dependency",                             feature,-                            dep-                        )-                    } else {-                        anyhow::bail!(-                            "Feature `{}` depends on `{}` which is not an \-                             optional dependency.\nConsider adding \-                             `optional = true` to the dependency",+                            fv,+                            dep_name+                        );+                    }+                    if !is_optional_dep {+                        bail!(+                            "feature `{}` includes `{}`, but `{}` is not an optional dependency\n\+                             A non-optional dependency of the same name is defined; \+                             consider adding `optional = true` to its definition.",                             feature,-                            dep-                        )+                            fv,+                            dep_name+                        );                     }                 }-                // If namespaced, the value was tagged as a dependency; if not namespaced,-                // this could be anything not defined as a feature. This handles the case-                // where no such dependency is actually defined; again, the branch on-                // namespaced here is just to provide the correct string in the error.-                (&Crate(ref dep), false, _) => {-                    if namespaced {-                        anyhow::bail!(-                            "Feature `{}` includes `crate:{}` which is not a known \-                             dependency",-                            feature,-                            dep-                        )-                    } else {-                        anyhow::bail!(-                            "Feature `{}` includes `{}` which is neither a dependency nor \-                             another feature",+                CrateFeature { dep_name, .. } => {+                    // Validation of the feature name will be performed in the resolver.+                    if !is_any_dep {+                        bail!(+                            "feature `{}` includes `{}`, but `{}` is not a dependency",                             feature,-                            dep-                        )+                            fv,+                            dep_name+                        );                     }                 }-                (&Crate(_), true, true) => {}-                // If the value is a feature for one of the dependencies, bail out if no such-                // dependency is actually defined in the manifest.-                (&CrateFeature(ref dep, _), false, _) => anyhow::bail!(-                    "Feature `{}` requires a feature of `{}` which is not a \-                     dependency",-                    feature,-                    dep-                ),-                (&CrateFeature(_, _), true, _) => {}             }-            values.push(val);-        }--        if !dependency_found {-            // If we have not found the dependency of the same-named feature, we should-            // bail here.-            anyhow::bail!(-                "Feature `{}` includes the optional dependency of the \-                 same name, but this is left implicit in the features \-                 included by this feature.\nConsider adding \-                 `crate:{}` to this feature's requirements.",-                feature,-                feature-            )         }+    } -        map.insert(InternedString::new(feature.borrow()), values);+    // Make sure every optional dep is mentioned at least once.+    let used: HashSet<_> = map+        .values()+        .flatten()+        .filter_map(|fv| match fv {+            Crate { dep_name } | CrateFeature { dep_name, .. } => Some(dep_name),+            _ => None,+        })+        .collect();+    if let Some(dep) = dependencies+        .iter()+        .find(|dep| dep.is_optional() && !used.contains(&dep.name_in_toml()))+    {+        bail!(+            "optional dependency `{}` is not included in any feature\n\+            Make sure that `crate:{}` is included in one of features in the [features] table.",+            dep.name_in_toml(),+            dep.name_in_toml(),+        );     }-    Ok(map)++    Ok((map, has_namespaced_features)) } -/// FeatureValue represents the types of dependencies a feature can have:-///-/// * Another feature-/// * An optional dependency-/// * A feature in a dependency-///-/// The selection between these 3 things happens as part of the construction of the FeatureValue.+/// FeatureValue represents the types of dependencies a feature can have. #[derive(Clone, Debug)] pub enum FeatureValue {+    /// A feature enabling another feature.     Feature(InternedString),-    Crate(InternedString),-    CrateFeature(InternedString, InternedString),+    /// A feature enabling a dependency with `crate:dep_name` syntax.+    Crate { dep_name: InternedString },+    /// A feature enabling a feature on a dependency with `crate_name/feat_name` syntax.+    CrateFeature {+        dep_name: InternedString,+        dep_feature: InternedString,+        /// If this is true, then the feature used the `crate:` prefix, which+        /// prevents enabling the feature named `dep_name`.+        explicit: bool,+    }, }  impl FeatureValue {-    fn build<T>(feature: InternedString, is_feature: T, namespaced: bool) -> FeatureValue-    where-        T: Fn(InternedString) -> bool,-    {-        match (feature.find('/'), namespaced) {-            (Some(pos), _) => {+    pub fn new(feature: InternedString) -> FeatureValue {+        match feature.find('/') {+            Some(pos) => {                 let (dep, dep_feat) = feature.split_at(pos);                 let dep_feat = &dep_feat[1..];-                FeatureValue::CrateFeature(InternedString::new(dep), InternedString::new(dep_feat))-            }-            (None, true) if feature.starts_with("crate:") => {-                FeatureValue::Crate(InternedString::new(&feature[6..]))-            }-            (None, true) => FeatureValue::Feature(feature),-            (None, false) if is_feature(feature) => FeatureValue::Feature(feature),-            (None, false) => FeatureValue::Crate(feature),-        }-    }--    pub fn new(feature: InternedString, s: &Summary) -> FeatureValue {-        Self::build(-            feature,-            |fs| s.features().contains_key(&fs),-            s.namespaced_features(),-        )-    }--    pub fn to_string(&self, s: &Summary) -> String {-        use self::FeatureValue::*;-        match *self {-            Feature(ref f) => f.to_string(),-            Crate(ref c) => {-                if s.namespaced_features() {-                    format!("crate:{}", &c)+                let (dep, explicit) = if dep.starts_with("crate:") {

+//! Tests for namespaced features.++use cargo_test_support::project;+use cargo_test_support::registry::{Dependency, Package};++#[cargo_test]+fn gated() {+    // Need namespaced-features to use `crate:` syntax.+    Package::new("bar", "1.0.0").publish();+    let p = project()+        .file(+            "Cargo.toml",+            r#"+                [package]+                name = "foo"+                version = "0.1.0"++                [dependencies]+                bar = { version = "1.0", optional = true }++                [features]+                foo = ["crate:bar"]+            "#,+        )+        .file("src/lib.rs", "")+        .build();++    p.cargo("check")+        .with_status(101)+        .with_stderr(+            "\+[ERROR] failed to parse manifest at `[..]/foo/Cargo.toml`++Caused by:+  namespaced features with the `crate:` prefix are only allowed on the nightly channel \+  and requires the `-Z namespaced-features` flag on the command-line+",+        )+        .run();+}++#[cargo_test]+fn dependency_gate_ignored() {+    // Dependencies with `crate:` features are ignored in the registry if not on nightly.+    Package::new("baz", "1.0.0").publish();+    Package::new("bar", "1.0.0")+        .add_dep(Dependency::new("baz", "1.0").optional(true))+        .feature("feat", &["crate:baz"])+        .publish();+    let p = project()+        .file(+            "Cargo.toml",+            r#"+                [package]+                name = "foo"+                version = "0.1.0"++                [dependencies]+                bar = "1.0"+            "#,+        )+        .file("src/lib.rs", "")+        .build();++    p.cargo("check")+        .masquerade_as_nightly_cargo()+        .with_status(101)+        .with_stderr(+            "\+[UPDATING] [..]+[ERROR] no matching package named `bar` found+location searched: registry `https://github.com/rust-lang/crates.io-index`+required by package `foo v0.1.0 ([..]/foo)`+",+        )+        .run();++    // Publish a version without namespaced features, it should ignore 1.0.0+    // an use this instead.+    Package::new("bar", "1.0.1")+        .add_dep(Dependency::new("baz", "1.0").optional(true))+        .feature("feat", &["baz"])+        .publish();+    p.cargo("check")+        .masquerade_as_nightly_cargo()+        .with_stderr(+            "\+[UPDATING] [..]+[DOWNLOADING] crates ...+[DOWNLOADED] bar [..]+[CHECKING] bar v1.0.1+[CHECKING] foo v0.1.0 [..]+[FINISHED] [..]+",+        )+        .run();+}++#[cargo_test]+fn dependency_with_crate_syntax() {+    // Registry dependency uses crate: syntax.+    Package::new("baz", "1.0.0").publish();+    Package::new("bar", "1.0.0")+        .add_dep(Dependency::new("baz", "1.0").optional(true))+        .feature("feat", &["crate:baz"])

 impl<'a, 'cfg> FeatureResolver<'a, 'cfg> {                         }                         if dep.is_optional() {                             // Activate the crate on self.-                            let fv = FeatureValue::Crate(*dep_name);+                            let fv = FeatureValue::Crate {+                                dep_name: *dep_name,+                                // explicit: *explicit,

 impl<'a> Object<'a> {         let (sym, _addr) = self.syms.get(i)?;         Some(sym)     }++    pub(super) fn object_mapping(&self, addr: u64) -> Option<(Mapping, u64)> {+        let object_map = self.object_map.as_ref()?;+        let symbol = object_map.get(addr)?;+        let object_path = symbol.object(object_map);+        if let Some((archive_path, member_name)) = split(object_path) {+            let map = super::mmap(Path::new(archive_path))?;+            let archive = object::read::archive::ArchiveFile::parse(&map).ok()?;+            let mut members = archive.members();+            while let Ok(Some(member)) = members.next() {+                if member.name() == member_name.as_bytes() {+                    let (macho, data) = find_header(Bytes(member.data()))?;+                    let endian = macho.endian().ok()?;+                    let object = Object::parse(macho, endian, data)?;+                    for object_symbol in &object.syms {+                        if object_symbol.0 == symbol.name().as_bytes() {+                            let object_addr = addr.wrapping_sub(symbol.address()).wrapping_add(object_symbol.1);+                            let stash = Stash::new();+                            let inner = super::cx(&stash, object)?;+                            return Some((mk!(Mapping { map, inner, stash }), object_addr));+                        }+                    }+                }+            }+        } else {+            let map = super::mmap(Path::new(object_path))?;+            let (macho, data) = find_header(Bytes(&map))?;+            let endian = macho.endian().ok()?;+            let object = Object::parse(macho, endian, data)?;+            for object_symbol in &object.syms {+                if object_symbol.0 == symbol.name().as_bytes() {+                    let object_addr = addr.wrapping_sub(symbol.address()).wrapping_add(object_symbol.1);+                    let stash = Stash::new();+                    let inner = super::cx(&stash, object)?;+                    return Some((mk!(Mapping { map, inner, stash }), object_addr));+                }+            }+        }+        None+    }+}++fn split(path: &str) -> Option<(&str, &str)> {+    let index = path.find('(')?;+    let (archive, rest) = path.split_at(index);