Skip to main content

cargo/lints/rules/
unused_workspace_package_fields.rs

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