feat: Add lint for global use of hint-mostly-unused

Author: Muscraft

src/cargo/core/workspace.rs

@@ -25,7 +25,7 @@ use crate::util::context::FeatureUnification;
 use crate::util::edit_distance;
 use crate::util::errors::{CargoResult, ManifestError};
 use crate::util::interning::InternedString;
-use crate::util::lints::{analyze_cargo_lints_table, check_im_a_teapot};
+use crate::util::lints::{analyze_cargo_lints_table, check_im_a_teapot, global_mostly_unused};
 use crate::util::toml::{InheritableFields, read_manifest};
 use crate::util::{
  Filesystem, GlobalContext, IntoUrl, context::CargoResolverConfig, context::ConfigRelativePath,
@@ -409,10 +409,7 @@ impl<'gctx> Workspace<'gctx> {
  }
 
  pub fn profiles(&self) -> Option<&TomlProfiles> {
- match self.root_maybe() {
- MaybePackage::Package(p) => p.manifest().profiles(),
- MaybePackage::Virtual(vm) => vm.profiles(),
- }
+ self.root_maybe().profiles()
  }
 
  /// Returns the root path of this workspace.
@@ -907,10 +904,7 @@ impl<'gctx> Workspace<'gctx> {
 
  /// Returns the unstable nightly-only features enabled via `cargo-features` in the manifest.
  pub fn unstable_features(&self) -> &Features {
- match self.root_maybe() {
- MaybePackage::Package(p) => p.manifest().unstable_features(),
- MaybePackage::Virtual(vm) => vm.unstable_features(),
- }
+ self.root_maybe().unstable_features()
  }
 
  pub fn resolve_behavior(&self) -> ResolveBehavior {
@@ -1206,10 +1200,20 @@ impl<'gctx> Workspace<'gctx> {
 
  pub fn emit_warnings(&self) -> CargoResult<()> {
  let mut first_emitted_error = None;
+
+ let cli_unstable = self.gctx.cli_unstable();
+ if cli_unstable.cargo_lints || cli_unstable.profile_hint_mostly_unused {
+ if let Err(e) = self.emit_ws_lints()
+ && first_emitted_error.is_none()
+ {
+ first_emitted_error = Some(e);
+ }
+ }
+
  for (path, maybe_pkg) in &self.packages.packages {
  if let MaybePackage::Package(pkg) = maybe_pkg {
- if self.gctx.cli_unstable().cargo_lints {
- if let Err(e) = self.emit_lints(pkg, &path)
+ if cli_unstable.cargo_lints {
+ if let Err(e) = self.emit_pkg_lints(pkg, &path)
  && first_emitted_error.is_none()
  {
  first_emitted_error = Some(e);
@@ -1248,7 +1252,7 @@ impl<'gctx> Workspace<'gctx> {
  }
  }
 
- pub fn emit_lints(&self, pkg: &Package, path: &Path) -> CargoResult<()> {
+ pub fn emit_pkg_lints(&self, pkg: &Package, path: &Path) -> CargoResult<()> {
  let mut error_count = 0;
  let toml_lints = pkg
  .manifest()
@@ -1262,15 +1266,9 @@ impl<'gctx> Workspace<'gctx> {
  .cloned()
  .unwrap_or(manifest::TomlToolLints::default());
 
- let ws_contents = match self.root_maybe() {
- MaybePackage::Package(pkg) => pkg.manifest().contents(),
- MaybePackage::Virtual(v) => v.contents(),
- };
+ let ws_contents = self.root_maybe().contents();
 
- let ws_document = match self.root_maybe() {
- MaybePackage::Package(pkg) => pkg.manifest().document(),
- MaybePackage::Virtual(v) => v.document(),
- };
+ let ws_document = self.root_maybe().document();
 
  analyze_cargo_lints_table(
  pkg,
@@ -1282,6 +1280,49 @@ impl<'gctx> Workspace<'gctx> {
  self.gctx,
  )?;
  check_im_a_teapot(pkg, &path, &cargo_lints, &mut error_count, self.gctx)?;
+
+ if error_count > 0 {
+ Err(crate::util::errors::AlreadyPrintedError::new(anyhow!(
+ "encountered {error_count} errors(s) while running lints"
+ ))
+ .into())
+ } else {
+ Ok(())
+ }
+ }
+
+ pub fn emit_ws_lints(&self) -> CargoResult<()> {
+ let mut error_count = 0;
+
+ let cargo_lints = match self.root_maybe() {
+ MaybePackage::Package(pkg) => {
+ let toml = pkg.manifest().normalized_toml();
+ if let Some(ws) = &toml.workspace {
+ ws.lints.as_ref()
+ } else {
+ toml.lints.as_ref().map(|l| &l.lints)
+ }
+ }
+ MaybePackage::Virtual(vm) => vm
+ .normalized_toml()
+ .workspace
+ .as_ref()
+ .unwrap()
+ .lints
+ .as_ref(),
+ }
+ .and_then(|t| t.get("cargo"))
+ .cloned()
+ .unwrap_or(manifest::TomlToolLints::default());
+
+ global_mostly_unused(
+ self.root_maybe(),
+ self.root_manifest(),
+ &cargo_lints,
+ &mut error_count,
+ self.gctx,
+ )?;
+
  if error_count > 0 {
  Err(crate::util::errors::AlreadyPrintedError::new(anyhow!(
  "encountered {error_count} errors(s) while running lints"
@@ -1888,6 +1929,41 @@ impl MaybePackage {
  MaybePackage::Virtual(_) => false,
  }
  }
+
+ pub fn contents(&self) -> &str {
+ match self {
+ MaybePackage::Package(p) => p.manifest().contents(),
+ MaybePackage::Virtual(v) => v.contents(),
+ }
+ }
+
+ pub fn document(&self) -> &toml::Spanned<toml::de::DeTable<'static>> {
+ match self {
+ MaybePackage::Package(p) => p.manifest().document(),
+ MaybePackage::Virtual(v) => v.document(),
+ }
+ }
+
+ pub fn edition(&self) -> Edition {
+ match self {
+ MaybePackage::Package(p) => p.manifest().edition(),
+ MaybePackage::Virtual(_) => Edition::default(),
+ }
+ }
+
+ pub fn profiles(&self) -> Option<&TomlProfiles> {
+ match self {
+ MaybePackage::Package(p) => p.manifest().profiles(),
+ MaybePackage::Virtual(v) => v.profiles(),
+ }
+ }
+
+ pub fn unstable_features(&self) -> &Features {
+ match self {
+ MaybePackage::Package(p) => p.manifest().unstable_features(),
+ MaybePackage::Virtual(vm) => vm.unstable_features(),
+ }
+ }
 }
 
 impl WorkspaceRootConfig {

src/cargo/util/lints.rs

@@ -1,14 +1,14 @@
-use crate::core::{Edition, Feature, Features, Manifest, Package};
+use crate::core::{Edition, Feature, Features, Manifest, MaybePackage, Package};
 use crate::{CargoResult, GlobalContext};
 use annotate_snippets::{AnnotationKind, Group, Level, Snippet};
-use cargo_util_schemas::manifest::{TomlLintLevel, TomlToolLints};
+use cargo_util_schemas::manifest::{ProfilePackageSpec, TomlLintLevel, TomlToolLints};
 use pathdiff::diff_paths;
 use std::fmt::Display;
 use std::ops::Range;
 use std::path::Path;
 
 const LINT_GROUPS: &[LintGroup] = &[TEST_DUMMY_UNSTABLE];
-pub const LINTS: &[Lint] = &[IM_A_TEAPOT, UNKNOWN_LINTS];
+pub const LINTS: &[Lint] = &[GLOBAL_HINT_MOSTLY_UNUSED, IM_A_TEAPOT, UNKNOWN_LINTS];
 
 pub fn analyze_cargo_lints_table(
  pkg: &Package,
@@ -473,6 +473,114 @@ pub fn check_im_a_teapot(
  Ok(())
 }
 
+const GLOBAL_HINT_MOSTLY_UNUSED: Lint = Lint {
+ name: "global_hint_mostly_unused",
+ desc: "global_hint_mostly_unused lint",
+ groups: &[],
+ default_level: LintLevel::Warn,
+ edition_lint_opts: None,
+ feature_gate: None,
+ docs: Some(
+ r#"
+### What it does
+Checks if `hint-mostly-unused` being applied to all dependencies.
+
+### Why it is bad
+`hint-mostly-unused` indicates that most of a crate's API surface will go
+unused by anything depending on it; this hint can speed up the build by
+attempting to minimize compilation time for items that aren't used at all.
+Misapplication to crates that don't fit that criteria will slow down the build
+rather than speeding it up. It should be selectively applied to dependencies
+that meet these criteria. Applying it globally is always a misapplication and
+will likely slow down the build.
+
+### Example
+```toml
+[profile.dev.package."*"]
+hint-mostly-unused = true
+```
+
+Should instead be:
+```toml
+[profile.dev.package.huge-mostly-unused-dependency]
+hint-mostly-unused = true
+```
+"#,
+ ),
+};
+
+pub fn global_mostly_unused(
+ maybe_pkg: &MaybePackage,
+ path: &Path,
+ pkg_lints: &TomlToolLints,
+ error_count: &mut usize,
+ gctx: &GlobalContext,
+) -> CargoResult<()> {
+ let (lint_level, reason) = GLOBAL_HINT_MOSTLY_UNUSED.level(
+ pkg_lints,
+ maybe_pkg.edition(),
+ maybe_pkg.unstable_features(),
+ );
+
+ if lint_level == LintLevel::Allow {
+ return Ok(());
+ }
+
+ let level = lint_level.to_diagnostic_level();
+ let manifest_path = rel_cwd_manifest_path(path, gctx);
+ let mut paths = Vec::new();
+
+ if let Some(profiles) = maybe_pkg.profiles() {
+ for (profile_name, top_level_profile) in &profiles.0 {
+ if let Some(true) = top_level_profile.hint_mostly_unused {
+ paths.push(vec!["profile", profile_name.as_str(), "hint-mostly-unused"]);
+ }
+
+ if let Some(packages) = &top_level_profile.package
+ && let Some(profile) = packages.get(&ProfilePackageSpec::All)
+ && let Some(true) = profile.hint_mostly_unused
+ {
+ paths.push(vec![
+ "profile",
+ profile_name.as_str(),
+ "package",
+ "*",
+ "hint-mostly-unused",
+ ]);
+ }
+ }
+ }
+
+ for (i, path) in paths.iter().enumerate() {
+ if lint_level.is_error() {
+ *error_count += 1;
+ }
+ let title = "`hint-mostly-unused` should not be applied globally";
+ if let (Some(span), Some(table_span)) = (
+ get_key_value_span(maybe_pkg.document(), &path),
+ get_key_value_span(maybe_pkg.document(), &path[..path.len() - 1]),
+ ) {
+ let mut group = level.clone().primary_title(title).element(
+ Snippet::source(maybe_pkg.contents())
+ .path(&manifest_path)
+ .annotation(AnnotationKind::Primary.span(span.key.start..span.value.end))
+ .annotation(AnnotationKind::Visible.span(table_span.key)),
+ );
+
+ if i == 0 {
+ group = group.element(
+ Level::NOTE
+ .message(GLOBAL_HINT_MOSTLY_UNUSED.emitted_source(lint_level, reason)),
+ );
+ }
+
+ gctx.shell().print_report(&[group], lint_level.force())?;
+ }
+ }
+
+ Ok(())
+}
+
 const UNKNOWN_LINTS: Lint = Lint {
  name: "unknown_lints",
  desc: "unknown lint",

src/doc/src/reference/lints.md

@@ -5,8 +5,37 @@ Note: [Cargo's linting system is unstable](unstable.md#lintscargo) and can only
 ## Warn-by-default
 
 These lints are all set to the 'warn' level by default.
+- [`global_hint_mostly_unused`](#global_hint_mostly_unused)
 - [`unknown_lints`](#unknown_lints)
 
+## `global_hint_mostly_unused`
+Set to `warn` by default
+
+### What it does
+Checks if `hint-mostly-unused` being applied to all dependencies.
+
+### Why it is bad
+`hint-mostly-unused` indicates that most of a crate's API surface will go
+unused by anything depending on it; this hint can speed up the build by
+attempting to minimize compilation time for items that aren't used at all.
+Misapplication to crates that don't fit that criteria will slow down the build
+rather than speeding it up. It should be selectively applied to dependencies
+that meet these criteria. Applying it globally is always a misapplication and
+will likely slow down the build.
+
+### Example
+```toml
+[profile.dev.package."*"]
+hint-mostly-unused = true
+```
+
+Should instead be:
+```toml
+[profile.dev.package.huge-mostly-unused-dependency]
+hint-mostly-unused = true
+```
+
+
 ## `unknown_lints`
 Set to `warn` by default