Skip to main content

cargo/diagnostics/rules/
unused_workspace_package_fields.rs

1use std::path::Path;
2
3use cargo_util_schemas::manifest::TomlToolLints;
4use cargo_util_terminal::report::AnnotationKind;
5use cargo_util_terminal::report::Group;
6use cargo_util_terminal::report::Level;
7use cargo_util_terminal::report::Origin;
8use cargo_util_terminal::report::Patch;
9use cargo_util_terminal::report::Snippet;
10use indexmap::IndexSet;
11use tracing::instrument;
12
13use super::SUSPICIOUS;
14use crate::CargoResult;
15use crate::GlobalContext;
16use crate::core::MaybePackage;
17use crate::core::Workspace;
18use crate::diagnostics::DiagnosticStats;
19use crate::diagnostics::Lint;
20use crate::diagnostics::LintLevel;
21use crate::diagnostics::get_key_value_span;
22use crate::diagnostics::rel_cwd_manifest_path;
23
24pub static LINT: &Lint = &Lint {
25    name: "unused_workspace_package_fields",
26    desc: "unused field in `workspace.package`",
27    primary_group: &SUSPICIOUS,
28    msrv: Some(super::CARGO_LINTS_MSRV),
29    feature_gate: None,
30    docs: Some(
31        r#"
32### What it does
33Checks for any fields in `[workspace.package]` that has not been inherited
34
35### Why it is bad
36They can give the false impression that these fields are used
37
38### Example
39```toml
40[workspace.package]
41edition = "2024"
42
43[package]
44name = "foo"
45```
46"#,
47    ),
48};
49
50#[instrument(skip_all)]
51pub fn unused_workspace_package_fields(
52    ws: &Workspace<'_>,
53    maybe_pkg: &MaybePackage,
54    manifest_path: &Path,
55    cargo_lints: &TomlToolLints,
56    stats: &mut DiagnosticStats,
57    gctx: &GlobalContext,
58) -> CargoResult<()> {
59    let (lint_level, source) = LINT.level(
60        cargo_lints,
61        ws.lowest_rust_version(),
62        maybe_pkg.unstable_features(),
63    );
64    if lint_level == LintLevel::Allow {
65        return Ok(());
66    }
67
68    let workspace_package_fields: IndexSet<_> = maybe_pkg
69        .document()
70        .and_then(|d| d.get_ref().get("workspace"))
71        .and_then(|w| w.get_ref().get("package"))
72        .and_then(|p| p.get_ref().as_table())
73        .iter()
74        .flat_map(|d| d.keys())
75        .collect();
76
77    let mut inherited_fields = IndexSet::new();
78    for member in ws.members() {
79        inherited_fields.extend(
80            member
81                .manifest()
82                .document()
83                .and_then(|w| w.get_ref().get("package"))
84                .and_then(|p| p.get_ref().as_table())
85                .iter()
86                .flat_map(|d| {
87                    d.iter()
88                        .filter(|(_, v)| {
89                            v.get_ref()
90                                .get("workspace")
91                                .and_then(|w| w.get_ref().as_bool())
92                                == Some(true)
93                        })
94                        .map(|(k, _)| k)
95                }),
96        );
97    }
98
99    for (i, unused) in workspace_package_fields
100        .difference(&inherited_fields)
101        .enumerate()
102    {
103        let document = maybe_pkg.document();
104        let contents = maybe_pkg.contents();
105        let level = lint_level.to_diagnostic_level();
106        let manifest_path = rel_cwd_manifest_path(manifest_path, gctx);
107        let emitted_source = LINT.emitted_source(lint_level, source);
108
109        let mut primary = Group::with_title(level.primary_title(LINT.desc));
110        if let Some(document) = document
111            && let Some(contents) = contents
112        {
113            let mut snippet = Snippet::source(contents).path(&manifest_path);
114            if let Some(span) =
115                get_key_value_span(document, &["workspace", "package", unused.as_ref()])
116            {
117                snippet = snippet.annotation(AnnotationKind::Primary.span(span.key));
118            }
119            primary = primary.element(snippet);
120        } else {
121            primary = primary.element(Origin::path(&manifest_path));
122        }
123        if i == 0 {
124            primary = primary.element(Level::NOTE.message(emitted_source));
125        }
126        let mut report = vec![primary];
127        if let Some(document) = document
128            && let Some(contents) = contents
129        {
130            let mut help = Group::with_title(
131                Level::HELP.secondary_title("consider removing the unused field"),
132            );
133            let mut snippet = Snippet::source(contents).path(&manifest_path);
134            if let Some(span) =
135                get_key_value_span(document, &["workspace", "package", unused.as_ref()])
136            {
137                snippet = snippet.patch(Patch::new(span.key.start..span.value.end, ""));
138            }
139            help = help.element(snippet);
140            report.push(help);
141        }
142
143        stats.record_lint(lint_level);
144        gctx.shell().print_report(&report, lint_level.force())?;
145    }
146
147    Ok(())
148}