lints

parse.rs (24183B)

---

 use super::{
     ExitCode, HashSet, convert,
     io::{self, Write as _},
 };
 use core::{
     cmp::Ordering,
     hash::{Hash, Hasher},
 };
 /// Unit tests.
 #[cfg(test)]
 mod tests;
 // We skip all lines until: "name  default  meaning" trimming leading spaces.
 // We verify the next line is "----  -------  -------" trimming leading spaces.
 //
 // Next we grab the lints.
 // The regex for lints is verified to be `^ *[\-0-9A-Za-z]+ +(allow|warn|deny) +.*$`.
 //
 // We verify all three kinds of lints are non-empty and no lint exists more than once. We verify the
 // `warn` lints contain a lint called "warnings" which does not count towards the emptiness of
 // `warn` lints.
 //
 // Next we skip all lines until: "name  sub-lints" trimming leading spaces.
 // We verify the next line is "----  ---------" trimming leading spaces.
 //
 // Next we grab the lint groups.
 // The regex for lint groups is verified to be `^ +[\-0-9A-Za-z]+ +[ ,\-0-9A-Za-z]+$`.
 //
 // We verify lint group names are unique among themselves and the individual lints sans `"warnings"`
 // which is allowed to exist.
 // We verify the lint groups are non-empty except "warnings" if it is defined.
 // We verify each lint in a lint group is unique.
 // We verify each lint is the name of one of the lints unless `--allow-undefined-lints` was passed.
 // We verify when there is multiple lints, each lint is separated with a single comma and space.
 /// Error from parsing.
 #[cfg_attr(test, derive(Debug, PartialEq))]
 pub(crate) enum E<'a> {
     /// Output doesn't start as expected.
     Start,
     /// The contained line is not the format of a lint.
     UnexpectedLintLine(&'a [u8]),
     /// The contained lint appeared more than once.
     DuplicateLint(&'a [u8]),
     /// There wasn't a `warn`-by-default lint called `"warnings"`.
     MissingWarningLint,
     /// There were no `allow`-by-default lints.
     NoAllowLints,
     /// There were no `warn`-by-default lints except for `"warnings"`.
     NoWarnLints,
     /// There were no `deny`-by-default lints.
     NoDenyLints,
     /// Output doesn't contain what it should between the lints and lint groups.
     Middle,
     /// The contained line is not the format of a lint group.
     UnexpectedLintGroupLine(&'a [u8]),
     /// The contained lint group name appeared more than once.
     DuplicateLintGroup(&'a [u8]),
     /// The contained lint group name is the same as the name of a lint.
     LintSameNameAsLintGroup(&'a [u8]),
     /// The contained lint group name contained a lint more than once.
     LintGroupContainsDuplicateLint(&'a [u8], &'a [u8]),
     /// The contained lint group name contained an unknown lint.
     LintGroupContainsUnknownLint(&'a [u8], &'a [u8]),
     /// The contained lint group name has no lints.
     EmptyLintGroup(&'a [u8]),
     /// There were no lint groups.
     NoLintGroups,
     /// Output doesn't end as expected.
     End,
 }
 /// Lines before lints.
 const START: &str = "name  default  meaning
 ----  -------  -------";
 /// Lines between lints and lint groups.
 const MIDDLE: &str = "
 name  sub-lints
 ----  ---------";
 impl E<'_> {
     /// Writes `self` into `stderr`.
     pub(crate) fn into_exit_code(self) -> ExitCode {
         let mut stderr = io::stderr().lock();
         match self {
             Self::Start => writeln!(stderr, "rustc -Whelp doesn't contain '{START}' ignoring leading spaces"),
             Self::UnexpectedLintLine(line) => writeln!(
                 stderr,
                 "rustc -Whelp contained the following line that is not the expected format of a lint: {}.",
                 String::from_utf8_lossy(line),
             ),
             Self::DuplicateLint(lint) => writeln!(
                 stderr,
                 "rustc -Whelp contained the lint '{}' more than once.",
                 super::as_str(lint)
             ),
             Self::MissingWarningLint => writeln!(
                 stderr,
                 "rustc -Whelp didn't contain a warn-by-default lint called 'warnings'."
             ),
             Self::NoAllowLints => writeln!(
                 stderr,
                 "rustc -Whelp didn't contain any allow-by-default lints."
             ),
             Self::NoWarnLints => writeln!(
                 stderr,
                 "rustc -Whelp didn't contain any warn-by-default lints except for 'warnings'."
             ),
             Self::NoDenyLints => writeln!(
                 stderr,
                 "rustc -Whelp didn't contain any deny-by-default lints."
             ),
             Self::Middle => writeln!(
                 stderr,
                 "rustc -Whelp doesn't contain '{MIDDLE}' ignoring leading spaces after the lints."
             ),
             Self::UnexpectedLintGroupLine(line) => writeln!(
                 stderr,
                 "rustc -Whelp contained the following line that is not the expected format of a lint group: {}.",
                 String::from_utf8_lossy(line),
             ),
             Self::DuplicateLintGroup(group) => {
                 writeln!(
                     stderr,
                     "rustc -Whelp contained multiple lint groups called '{}'.",
                     super::as_str(group)
                 )
             }
             Self::LintSameNameAsLintGroup(group) => {
                 writeln!(
                     stderr,
                     "rustc -Whelp contained a lint and lint group both named '{}'.",
                     super::as_str(group)
                 )
             }
             Self::LintGroupContainsDuplicateLint(group, lint) => writeln!(
                 stderr,
                 "rustc -Whelp contained the lint group '{}' which has the lint '{}' more than once.",
                 super::as_str(group),
                 super::as_str(lint),
             ),
             Self::LintGroupContainsUnknownLint(group, lint) => writeln!(
                 stderr,
                 "rustc -Whelp contained the lint group '{}' which has the unknown lint '{}'.",
                 super::as_str(group),
                 super::as_str(lint),
             ),
             Self::EmptyLintGroup(group) => {
                 writeln!(
                     stderr,
                     "rustc -Whelp contained the empty lint group '{}'.",
                     super::as_str(group),
                 )
             }
             Self::NoLintGroups => writeln!(
                 stderr,
                 "rustc -Whelp didn't contain any lint groups."
             ),
             Self::End => writeln!(stderr, "rustc -Whelp did not have at least one empty line after the lint groups."),
         }.map_or(ExitCode::FAILURE, |()| ExitCode::FAILURE)
     }
 }
 /// Moves `line` to start at the first non-space.
 #[expect(
     clippy::arithmetic_side_effects,
     clippy::indexing_slicing,
     reason = "comments justifies correctness"
 )]
 fn skip_leading_space(line: &mut &[u8]) {
     // The `usize` contained in the `Result` is at most `line.len()`, so indexing is fine.
     *line = &line[line
         .iter()
         .try_fold(0, |idx, b| {
             if *b == b' ' {
                 // `idx < line.len()`, so overflow is not possible.
                 Ok(idx + 1)
             } else {
                 Err(idx)
             }
         })
         .unwrap_or_else(convert::identity)..];
 }
 /// [`Iterator`] of lines.
 ///
 /// In the event a `b'\n'` doesn't exist, `None` will be returned. This means in the event the last
 /// "line" does not end with `b'\n'`, it won't be returned.
 struct Lines<'a>(&'a [u8]);
 impl<'a> Iterator for Lines<'a> {
     type Item = &'a [u8];
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "comments justify correctness"
     )]
     fn next(&mut self) -> Option<Self::Item> {
         self.0
             .iter()
             .try_fold(0, |idx, b| {
                 if *b == b'\n' {
                     Err(idx)
                 } else {
                     // `idx < self.0.len()`, so overflow is not possible.
                     Ok(idx + 1)
                 }
             })
             .map_or_else(
                 |idx| {
                     // `idx <= self.0.len()`, so this won't `panic`.
                     let (val, rem) = self.0.split_at(idx);
                     // `rem` starts with a newline, so this won't `panic`.
                     self.0 = &rem[1..];
                     Some(val)
                 },
                 |_| None,
             )
     }
 }
 /// Extracts the lint or lint group name from `line`.
 ///
 /// Returns `Some` iff a valid lint or lint group name is found ignoring leading spaces and
 /// if there is non-spaces after. The first `slice` is the name and the second slice is
 /// the remaining portion of `line` with leading spaces removed.
 #[expect(
     clippy::arithmetic_side_effects,
     reason = "comment justifies correctness"
 )]
 fn get_lint_name(mut line: &[u8]) -> Option<(&[u8], &[u8])> {
     skip_leading_space(&mut line);
     line.iter()
         .try_fold(0, |idx, b| {
             if *b == b' ' {
                 Err(Some(idx))
             } else if *b == b'-' || b.is_ascii_alphanumeric() {
                 // `idx < line.len()`, so overflow is not possible.
                 Ok(idx + 1)
             } else {
                 Err(None)
             }
         })
         .map_or_else(
             |opt| {
                 opt.and_then(|idx| {
                     let (name, mut rem) = line.split_at(idx);
                     let len = rem.len();
                     skip_leading_space(&mut rem);
                     if len == rem.len() {
                         None
                     } else {
                         Some((name, rem))
                     }
                 })
             },
             |_| None,
         )
 }
 /// The lints.
 ///
 /// All `HashSet`s are non-empty with no overlap. `warn` doesn't contain `"warnings"`.
 struct Lints<'a> {
     /// `allow`-by-default lints.
     allow: HashSet<&'a [u8]>,
     /// `warn`-by-default lints.
     warn: HashSet<&'a [u8]>,
     /// `deny`-by-default lints.
     deny: HashSet<&'a [u8]>,
 }
 /// `"warnings"`.
 pub(crate) const WARNINGS: &str = "warnings";
 impl<'a> Lints<'a> {
     /// Gets the lints from `lines` erring when there are duplicates, there is no `warn`-by-default
     /// lint called `"warnings"`, or the lints are empty (ignoring the `"warnings"` lint).
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "comments justify correctness"
     )]
     fn new(lines: &mut Lines<'a>) -> Result<Self, E<'a>> {
         /// Get the lint from `line`.
         ///
         /// Returns `Some` iff a valid lint name is found after removing leading spaces.
         /// The first `slice` is the name, and the second `slice` is the next "word".
         fn get_lint(line: &[u8]) -> Option<(&[u8], &[u8])> {
             get_lint_name(line).and_then(|(lint, rem)| {
                 rem.iter()
                     // `idx < rem.len()`, so overflow is not possible.
                     .try_fold(0, |idx, b| if *b == b' ' { Err(idx) } else { Ok(idx + 1) })
                     // `idx <= rem.len()`, so this won't `panic`.
                     .map_or_else(|idx| Some((lint, &rem[..idx])), |_| None)
             })
         }
         let mut allow = HashSet::with_capacity(128);
         let mut warn = HashSet::with_capacity(128);
         let mut deny = HashSet::with_capacity(128);
         lines
             .try_fold((), |(), line| {
                 if line.is_empty() {
                     Err(None)
                 } else {
                     get_lint(line)
                         .ok_or(Some(E::UnexpectedLintLine(line)))
                         .and_then(|(lint, status)| match status {
                             b"allow" => {
                                 if !allow.insert(lint) || warn.contains(lint) || deny.contains(lint)
                                 {
                                     Err(Some(E::DuplicateLint(lint)))
                                 } else {
                                     Ok(())
                                 }
                             }
                             b"warn" => {
                                 if !warn.insert(lint) || allow.contains(lint) || deny.contains(lint)
                                 {
                                     Err(Some(E::DuplicateLint(lint)))
                                 } else {
                                     Ok(())
                                 }
                             }
                             b"deny" => {
                                 if !deny.insert(lint) || allow.contains(lint) || warn.contains(lint)
                                 {
                                     Err(Some(E::DuplicateLint(lint)))
                                 } else {
                                     Ok(())
                                 }
                             }
                             _ => Err(Some(E::UnexpectedLintLine(line))),
                         })
                 }
             })
             .map_or_else(
                 |opt| {
                     opt.map_or_else(
                         || {
                             if warn.remove(WARNINGS.as_bytes()) {
                                 if allow.is_empty() {
                                     Err(E::NoAllowLints)
                                 } else if warn.is_empty() {
                                     Err(E::NoWarnLints)
                                 } else if deny.is_empty() {
                                     Err(E::NoDenyLints)
                                 } else {
                                     Ok(Self { allow, warn, deny })
                                 }
                             } else {
                                 Err(E::MissingWarningLint)
                             }
                         },
                         Err,
                     )
                 },
                 |()| Err(E::Middle),
             )
     }
 }
 /// [`Iterator`] of values separated by commas and spaces.
 ///
 /// In the event a value comes after a comma, a single leading space is assumed to exist and will be removed.
 struct Csv<'a>(&'a [u8]);
 impl<'a> Iterator for Csv<'a> {
     type Item = Result<&'a [u8], ()>;
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comments justify correctness"
     )]
     fn next(&mut self) -> Option<Self::Item> {
         /// `b", "`.
         const COMMA_SPACE: &[u8; 2] = b", ";
         (!self.0.is_empty()).then(|| {
             match self.0.iter().try_fold(0, |idx, b| {
                 if *b == b',' {
                     Err(idx)
                 } else {
                     // `idx < self.0.len()`, so overflow is not possible.
                     Ok(idx + 1)
                 }
             }) {
                 Ok(_) => {
                     let val = self.0;
                     self.0 = &[];
                     Ok(val)
                 }
                 Err(idx) => {
                     // `idx <= self.0.len()`, so this won't `panic`.
                     let (val, rem) = self.0.split_at(idx);
                     rem.split_at_checked(COMMA_SPACE.len())
                         .ok_or(())
                         .and_then(|(fst, fst_rem)| {
                             if fst == COMMA_SPACE {
                                 self.0 = fst_rem;
                                 Ok(val)
                             } else {
                                 Err(())
                             }
                         })
                 }
             }
         })
     }
 }
 /// Group of lints.
 pub(crate) struct LintGroup<'a> {
     /// Name of the group.
     pub name: &'a [u8],
     /// Lints that make up the group.
     pub lints: HashSet<&'a [u8]>,
 }
 impl Eq for LintGroup<'_> {}
 impl PartialEq for LintGroup<'_> {
     fn eq(&self, other: &Self) -> bool {
         self.name == other.name
     }
 }
 impl Hash for LintGroup<'_> {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.name.hash(state);
     }
 }
 impl PartialOrd for LintGroup<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for LintGroup<'_> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.name.cmp(other.name)
     }
 }
 /// Data from `rustc -Whelp`.
 pub(crate) struct Data<'a> {
     /// `allow`-by-default lints.
     pub allow: Vec<&'a [u8]>,
     /// `warn`-by-default lints.
     pub warn: Vec<&'a [u8]>,
     /// `deny`-by-default lints.
     pub deny: Vec<&'a [u8]>,
     /// Lint groups.
     pub groups: Vec<LintGroup<'a>>,
 }
 impl<'a> Data<'a> {
     /// Moves until the lints.
     ///
     /// Returns `true` iff the header was found.
     fn move_to_lints(lines: &mut Lines<'_>) -> bool {
         lines
             .try_fold((), |(), mut line| {
                 skip_leading_space(&mut line);
                 if line == b"name  default  meaning" {
                     Err(())
                 } else {
                     Ok(())
                 }
             })
             .map_or_else(
                 |()| {
                     lines.next().is_some_and(|mut line| {
                         skip_leading_space(&mut line);
                         line == b"----  -------  -------"
                     })
                 },
                 |()| false,
             )
     }
     /// Moves until the lint groups.
     ///
     /// Returns `true` iff the header was found.
     fn move_to_lint_groups(lines: &mut Lines<'_>) -> bool {
         lines
             .try_fold((), |(), mut line| {
                 skip_leading_space(&mut line);
                 if line == b"name  sub-lints" {
                     Err(())
                 } else {
                     Ok(())
                 }
             })
             .map_or_else(
                 |()| {
                     lines.next().is_some_and(|mut line| {
                         skip_leading_space(&mut line);
                         line == b"----  ---------"
                     })
                 },
                 |()| false,
             )
     }
     /// Gets the lint groups from `lines` erring when there are duplicate lint group names or if a lint group
     /// name is the name of a lint (with the exception of `"warnings"`), or if a group contains duplicate lints.
     /// In the event `allow_undefined_lints` is `false`, every lint in a lint group must exist in `single_lints`.
     fn get_lint_groups(
         output: &mut Lines<'a>,
         single_lints: &Lints<'_>,
         allow_undefined_lints: bool,
     ) -> Result<HashSet<LintGroup<'a>>, E<'a>> {
         let mut groups = HashSet::with_capacity(16);
         output
             .try_fold((), |(), line| {
                 if line.is_empty() {
                     Err(None)
                 } else {
                     get_lint_name(line)
                         .ok_or(Some(E::UnexpectedLintGroupLine(line)))
                         .and_then(|(name, group_lints)| {
                             if name == WARNINGS.as_bytes() {
                                 Ok(())
                             } else if single_lints.allow.contains(name)
                                 || single_lints.warn.contains(name)
                                 || single_lints.deny.contains(name)
                             {
                                 Err(Some(E::LintSameNameAsLintGroup(name)))
                             } else {
                                 let mut lints = HashSet::with_capacity(32);
                                 Csv(group_lints)
                                     .try_fold((), |(), res| {
                                         res.map_err(|()| Some(E::UnexpectedLintGroupLine(line)))
                                             .and_then(|lint| {
                                                 if allow_undefined_lints
                                                     || single_lints.allow.contains(lint)
                                                     || single_lints.warn.contains(lint)
                                                     || single_lints.deny.contains(lint)
                                                 {
                                                     if lints.insert(lint) {
                                                         Ok(())
                                                     } else {
                                                         Err(Some(
                                                             E::LintGroupContainsDuplicateLint(
                                                                 name, lint,
                                                             ),
                                                         ))
                                                     }
                                                 } else {
                                                     Err(Some(E::LintGroupContainsUnknownLint(
                                                         name, lint,
                                                     )))
                                                 }
                                             })
                                     })
                                     .and_then(|()| {
                                         if lints.is_empty() {
                                             Err(Some(E::EmptyLintGroup(name)))
                                         } else if groups.insert(LintGroup { name, lints }) {
                                             Ok(())
                                         } else {
                                             Err(Some(E::DuplicateLintGroup(name)))
                                         }
                                     })
                             }
                         })
                 }
             })
             .map_or_else(
                 |opt| {
                     opt.map_or_else(
                         || {
                             if groups.is_empty() {
                                 Err(E::NoLintGroups)
                             } else {
                                 Ok(groups)
                             }
                         },
                         Err,
                     )
                 },
                 |()| Err(E::End),
             )
     }
     /// Parses output and returns lints and lint groups.
     pub(crate) fn new(output: &'a [u8], allow_undefined_lints: bool) -> Result<Self, E<'a>> {
         let mut lines = Lines(output);
         if Self::move_to_lints(&mut lines) {
             Lints::new(&mut lines).and_then(|lints| {
                 if Self::move_to_lint_groups(&mut lines) {
                     Self::get_lint_groups(&mut lines, &lints, allow_undefined_lints).map(
                         |group_set| {
                             let mut allow = Vec::with_capacity(lints.allow.len());
                             lints.allow.into_iter().fold((), |(), lint| {
                                 allow.push(lint);
                             });
                             allow.sort_unstable();
                             let mut warn = Vec::with_capacity(lints.warn.len());
                             lints.warn.into_iter().fold((), |(), lint| {
                                 warn.push(lint);
                             });
                             warn.sort_unstable();
                             let mut deny = Vec::with_capacity(lints.deny.len());
                             lints.deny.into_iter().fold((), |(), lint| {
                                 deny.push(lint);
                             });
                             deny.sort_unstable();
                             let mut groups = Vec::with_capacity(group_set.len());
                             group_set.into_iter().fold((), |(), group| {
                                 groups.push(group);
                             });
                             groups.sort_unstable();
                             Self {
                                 allow,
                                 warn,
                                 deny,
                                 groups,
                             }
                         },
                     )
                 } else {
                     Err(E::Middle)
                 }
             })
         } else {
             Err(E::Start)
         }
     }
 }