Rename crate: to dep:

src/bin/cargo/cli.rs

@@ -42,7 +42,7 @@ Available unstable (nightly-only) flags:
  -Z timings -- Display concurrency information
  -Z doctest-xcompile -- Compile and run doctests for non-host target using runner config
  -Z terminal-width -- Provide a terminal width to rustc for error truncation
- -Z namespaced-features -- Allow features with `crate:` prefix
+ -Z namespaced-features -- Allow features with `dep:` prefix
 
 Run with 'cargo -Z [FLAG] [SUBCOMMAND]'"
  );

src/cargo/core/resolver/dep_cache.rs

@@ -342,7 +342,7 @@ pub fn resolve_features<'b>(
  }
 
  // This is a special case for command-line `--features
- // crate_name/feat_name` where `crate_name` does not exist. All other
+ // dep_name/feat_name` where `dep_name` does not exist. All other
  // validation is done either in `build_requirements` or
  // `build_feature_map`.
  for dep_name in reqs.deps.keys() {
@@ -374,9 +374,9 @@ fn build_requirements<'a, 'b: 'a>(
  } else {
  for &f in opts.features.features.iter() {
  let fv = FeatureValue::new(f);
- if fv.has_crate_prefix() {
+ if fv.has_dep_prefix() {
  return Err(ActivateError::Fatal(anyhow::format_err!(
- "feature value `{}` is not allowed to use explicit `crate:` syntax",
+ "feature value `{}` is not allowed to use explicit `dep:` syntax",
  fv
  )));
  }
@@ -438,16 +438,16 @@ impl Requirements<'_> {
  self.features
  }
 
- fn require_crate_feature(
+ fn require_dep_feature(
  &mut self,
  package: InternedString,
  feat: InternedString,
- crate_prefix: bool,
+ dep_prefix: bool,
  ) -> Result<(), RequirementError> {
  // If `package` is indeed an optional dependency then we activate the
  // feature named `package`, but otherwise if `package` is a required
  // dependency then there's no feature associated with it.
- if !crate_prefix
+ if !dep_prefix
  && self
  .summary
  .dependencies()
@@ -489,12 +489,12 @@ impl Requirements<'_> {
  fn require_value(&mut self, fv: &FeatureValue) -> Result<(), RequirementError> {
  match fv {
  FeatureValue::Feature(feat) => self.require_feature(*feat)?,
- FeatureValue::Crate { dep_name } => self.require_dependency(*dep_name),
- FeatureValue::CrateFeature {
+ FeatureValue::Dep { dep_name } => self.require_dependency(*dep_name),
+ FeatureValue::DepFeature {
  dep_name,
  dep_feature,
- crate_prefix,
- } => self.require_crate_feature(*dep_name, *dep_feature, *crate_prefix)?,
+ dep_prefix,
+ } => self.require_dep_feature(*dep_name, *dep_feature, *dep_prefix)?,
  };
  Ok(())
  }
@@ -526,7 +526,7 @@ impl RequirementError {
  match parent {
  None => ActivateError::Fatal(anyhow::format_err!(
  "Package `{}` does not have feature `{}`. It has an optional dependency \
- with that name, but that dependency uses the \"crate:\" \
+ with that name, but that dependency uses the \"dep:\" \
  syntax in the features table, so it does not have an implicit feature with that name.",
  summary.package_id(),
  feat
@@ -559,7 +559,7 @@ impl RequirementError {
  dep_name
  )),
  // This code path currently isn't used, since `foo/bar`
- // and `crate:` syntax is not allowed in a dependency.
+ // and `dep:` syntax is not allowed in a dependency.
  Some(p) => ActivateError::Conflict(
  p,
  ConflictReason::MissingFeatures(dep_name.to_string()),

src/cargo/core/resolver/errors.rs

@@ -170,7 +170,7 @@ pub(super) fn activation_error(
  msg.push_str("` does not have these features.\n");
  msg.push_str(
  " It has an optional dependency with that name, \
- but but that dependency uses the \"crate:\" \
+ but but that dependency uses the \"dep:\" \
  syntax in the features table, so it does not have an \
  implicit feature with that name.\n",
  );

src/cargo/core/resolver/features.rs

@@ -412,7 +412,7 @@ impl<'a, 'cfg> FeatureResolver<'a, 'cfg> {
  // For example, consider we've already processed our dependencies,
  // and another package comes along and enables one of our optional
  // dependencies, it will do so immediately in the
- // `FeatureValue::CrateFeature` branch, and then immediately
+ // `FeatureValue::DepFeature` branch, and then immediately
  // recurse into that optional dependency. This also holds true for
  // features that enable other features.
  return Ok(());
@@ -443,7 +443,7 @@ impl<'a, 'cfg> FeatureResolver<'a, 'cfg> {
  FeatureValue::Feature(f) => {
  self.activate_rec(pkg_id, *f, for_host)?;
  }
- FeatureValue::Crate { dep_name } => {
+ FeatureValue::Dep { dep_name } => {
  // Mark this dependency as activated.
  self.activated_dependencies
  .entry((pkg_id, self.opts.decouple_host_deps && for_host))
@@ -460,10 +460,10 @@ impl<'a, 'cfg> FeatureResolver<'a, 'cfg> {
  }
  }
  }
- FeatureValue::CrateFeature {
+ FeatureValue::DepFeature {
  dep_name,
  dep_feature,
- crate_prefix,
+ dep_prefix,
  } => {
  // Activate a feature within a dependency.
  for (dep_pkg_id, deps) in self.deps(pkg_id, for_host) {
@@ -472,12 +472,12 @@ impl<'a, 'cfg> FeatureResolver<'a, 'cfg> {
  continue;
  }
  if dep.is_optional() {
- // Activate the crate on self.
- let fv = FeatureValue::Crate {
+ // Activate the dependency on self.
+ let fv = FeatureValue::Dep {
  dep_name: *dep_name,
  };
  self.activate_fv(pkg_id, &fv, for_host)?;
- if !crate_prefix {
+ if !dep_prefix {
  // To retain compatibility with old behavior,
  // this also enables a feature of the same
  // name.

src/cargo/core/resolver/types.rs

@@ -297,7 +297,7 @@ pub enum ConflictReason {
  RequiredDependencyAsFeature(InternedString),
 
  /// A dependency listed a feature for an optional dependency, but that
- /// optional dependency is "hidden" using namespaced `crate:` syntax.
+ /// optional dependency is "hidden" using namespaced `dep:` syntax.
  NonImplicitDependencyAsFeature(InternedString),
 
  // TODO: needs more info for `activation_error`

src/cargo/core/summary.rs

@@ -88,7 +88,7 @@ impl Summary {
  if !namespaced_features {
  if self.inner.has_namespaced_features {
  bail!(
- "namespaced features with the `crate:` prefix are only allowed on \
+ "namespaced features with the `dep:` prefix are only allowed on \
  the nightly channel and requires the `-Z namespaced-features` flag on the command-line"
  );
  }
@@ -158,7 +158,7 @@ impl Hash for Summary {
 /// and creates FeatureValues for each feature.
 ///
 /// The returned `bool` indicates whether or not the `[features]` table
-/// included a `crate:` prefixed namespaced feature (used for gating on
+/// included a `dep:` prefixed namespaced feature (used for gating on
 /// nightly).
 fn build_feature_map(
  features: &BTreeMap<InternedString, Vec<InternedString>>,
@@ -183,18 +183,18 @@ fn build_feature_map(
  (*feature, fvs)
  })
  .collect();
- let has_namespaced_features = map.values().flatten().any(|fv| fv.has_crate_prefix());
+ let has_namespaced_features = map.values().flatten().any(|fv| fv.has_dep_prefix());
 
  // 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 { dep_name }
+ | DepFeature {
  dep_name,
- crate_prefix: true,
+ dep_prefix: true,
  ..
  } => Some(*dep_name),
  _ => None,
@@ -209,25 +209,25 @@ fn build_feature_map(
  {
  continue;
  }
- let fv = Crate {
+ let fv = Dep {
  dep_name: dep_name_in_toml,
  };
  map.insert(dep_name_in_toml, vec![fv]);
  }
 
  // Validate features are listed properly.
  for (feature, fvs) in &map {
- if feature.starts_with("crate:") {
+ if feature.starts_with("dep:") {
  bail!(
- "feature named `{}` is not allowed to start with `crate:`",
+ "feature named `{}` is not allowed to start with `dep:`",
  feature
  );
  }
  for fv in fvs {
  // Find data for the referenced dependency...
  let dep_data = {
  match fv {
- Feature(dep_name) | Crate { dep_name, .. } | CrateFeature { dep_name, .. } => {
+ Feature(dep_name) | Dep { dep_name, .. } | DepFeature { dep_name, .. } => {
  dep_map.get(dep_name)
  }
  }
@@ -253,7 +253,7 @@ fn build_feature_map(
  bail!(
  "feature `{}` includes `{}`, but `{}` is an \
  optional dependency without an implicit feature\n\
- Use `crate:{}` to enable the dependency.",
+ Use `dep:{}` to enable the dependency.",
  feature,
  fv,
  f,
@@ -268,7 +268,7 @@ fn build_feature_map(
  }
  }
  }
- Crate { dep_name } => {
+ Dep { dep_name } => {
  if !is_any_dep {
  bail!(
  "feature `{}` includes `{}`, but `{}` is not listed as a dependency",
@@ -288,7 +288,7 @@ fn build_feature_map(
  );
  }
  }
- CrateFeature { dep_name, .. } => {
+ DepFeature { dep_name, .. } => {
  // Validation of the feature name will be performed in the resolver.
  if !is_any_dep {
  bail!(
@@ -308,7 +308,7 @@ fn build_feature_map(
  .values()
  .flatten()
  .filter_map(|fv| match fv {
- Crate { dep_name } | CrateFeature { dep_name, .. } => Some(dep_name),
+ Dep { dep_name } | DepFeature { dep_name, .. } => Some(dep_name),
  _ => None,
  })
  .collect();
@@ -318,7 +318,7 @@ fn build_feature_map(
  {
  bail!(
  "optional dependency `{}` is not included in any feature\n\
- Make sure that `crate:{}` is included in one of features in the [features] table.",
+ Make sure that `dep:{}` is included in one of features in the [features] table.",
  dep.name_in_toml(),
  dep.name_in_toml(),
  );
@@ -332,15 +332,15 @@ fn build_feature_map(
 pub enum FeatureValue {
  /// A feature enabling another feature.
  Feature(InternedString),
- /// A feature enabling a dependency with `crate:dep_name` syntax.
- Crate { dep_name: InternedString },
+ /// A feature enabling a dependency with `dep:dep_name` syntax.
+ Dep { dep_name: InternedString },
  /// A feature enabling a feature on a dependency with `crate_name/feat_name` syntax.
- CrateFeature {
+ DepFeature {
  dep_name: InternedString,
  dep_feature: InternedString,
- /// If this is true, then the feature used the `crate:` prefix, which
+ /// If this is true, then the feature used the `dep:` prefix, which
  /// prevents enabling the feature named `dep_name`.
- crate_prefix: bool,
+ dep_prefix: bool,
  },
 }
 
@@ -350,27 +350,32 @@ impl FeatureValue {
  Some(pos) => {
  let (dep, dep_feat) = feature.split_at(pos);
  let dep_feat = &dep_feat[1..];
- let (dep, crate_prefix) = if let Some(dep) = dep.strip_prefix("crate:") {
+ let (dep, dep_prefix) = if let Some(dep) = dep.strip_prefix("dep:") {
  (dep, true)
  } else {
  (dep, false)
  };
- FeatureValue::CrateFeature {
+ FeatureValue::DepFeature {
  dep_name: InternedString::new(dep),
  dep_feature: InternedString::new(dep_feat),
- crate_prefix,
+ dep_prefix,
+ }
+ }
+ None => {
+ if let Some(dep_name) = feature.strip_prefix("dep:") {
+ FeatureValue::Dep {
+ dep_name: InternedString::new(dep_name),
+ }
+ } else {
+ FeatureValue::Feature(feature)
  }
  }
- None if feature.starts_with("crate:") => FeatureValue::Crate {
- dep_name: InternedString::new(&feature[6..]),
- },
- None => FeatureValue::Feature(feature),
  }
  }
 
- /// Returns `true` if this feature explicitly used `crate:` syntax.
- pub fn has_crate_prefix(&self) -> bool {
- matches!(self, FeatureValue::Crate{..} | FeatureValue::CrateFeature{crate_prefix:true, ..})
+ /// Returns `true` if this feature explicitly used `dep:` syntax.
+ pub fn has_dep_prefix(&self) -> bool {
+ matches!(self, FeatureValue::Dep{..} | FeatureValue::DepFeature{dep_prefix:true, ..})
  }
 }
 
@@ -379,16 +384,16 @@ impl fmt::Display for FeatureValue {
  use self::FeatureValue::*;
  match self {
  Feature(feat) => write!(f, "{}", feat),
- Crate { dep_name } => write!(f, "crate:{}", dep_name),
- CrateFeature {
+ Dep { dep_name } => write!(f, "dep:{}", dep_name),
+ DepFeature {
  dep_name,
  dep_feature,
- crate_prefix: true,
- } => write!(f, "crate:{}/{}", dep_name, dep_feature),
- CrateFeature {
+ dep_prefix: true,
+ } => write!(f, "dep:{}/{}", dep_name, dep_feature),
+ DepFeature {
  dep_name,
  dep_feature,
- crate_prefix: false,
+ dep_prefix: false,
  } => write!(f, "{}/{}", dep_name, dep_feature),
  }
  }

src/cargo/ops/cargo_compile.rs

@@ -1071,22 +1071,22 @@ fn validate_required_features(
  ))?;
  }
  }
- FeatureValue::Crate { .. }
- | FeatureValue::CrateFeature {
- crate_prefix: true, ..
+ FeatureValue::Dep { .. }
+ | FeatureValue::DepFeature {
+ dep_prefix: true, ..
  } => {
  anyhow::bail!(
  "invalid feature `{}` in required-features of target `{}`: \
- `crate:` prefixed feature values are not allowed in required-features",
+ `dep:` prefixed feature values are not allowed in required-features",
  fv,
  target_name
  );
  }
  // Handling of dependent_crate/dependent_crate_feature syntax
- FeatureValue::CrateFeature {
+ FeatureValue::DepFeature {
  dep_name,
  dep_feature,
- crate_prefix: false,
+ dep_prefix: false,
  } => {
  match resolve
  .deps(summary.package_id())