use oxc_ast::ast::Comment;
pub use fallow_types::suppress::{
IssueKind, RangeMarkerProblem, RangeMarkerProblemKind, Suppression, SuppressionScope,
SuppressionTarget, UnknownSuppressionKind, parse_suppression_target,
};
#[derive(Debug, Default, Clone)]
pub struct ParsedSuppressions {
pub suppressions: Vec<Suppression>,
pub unknown_kinds: Vec<UnknownSuppressionKind>,
pub range_markers: Vec<RangeMarker>,
pub range_problems: Vec<RangeMarkerProblem>,
pub line_markers: Vec<LineMarkerAt>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LineMarkerAt {
pub comment_line: u32,
pub offset: u32,
}
const RANGE_KIND: IssueKind = IssueKind::CodeDuplication;
#[derive(Debug, Clone)]
pub struct RangeMarker {
is_start: bool,
pub comment_line: u32,
next_line: u32,
pub offset: u32,
own_line: bool,
has_range_kind: bool,
is_blanket: bool,
unsupported: Vec<String>,
reason: Option<String>,
}
impl ParsedSuppressions {
pub fn pair_ranges(&mut self) {
let mut markers = std::mem::take(&mut self.range_markers);
markers.sort_by_key(|marker| marker.comment_line);
let mut open: Option<RangeMarker> = None;
for marker in markers {
if !marker.own_line {
self.push_range_problem(marker.comment_line, RangeMarkerProblemKind::NotOwnLine);
continue;
}
self.push_kind_problems(&marker);
if !marker.has_range_kind {
continue;
}
if marker.is_start {
if open.is_some() {
self.push_range_problem(
marker.comment_line,
RangeMarkerProblemKind::NestedStart,
);
} else {
open = Some(marker);
}
continue;
}
match open.take() {
Some(start) => self.suppressions.push(
Suppression::range(
start.next_line,
start.comment_line,
marker.comment_line,
RANGE_KIND,
)
.with_reason(start.reason),
),
None => {
self.push_range_problem(
marker.comment_line,
RangeMarkerProblemKind::UnmatchedEnd,
);
}
}
}
if let Some(start) = open {
self.push_range_problem(start.comment_line, RangeMarkerProblemKind::UnclosedStart);
}
self.range_problems.sort_by_key(|problem| problem.line);
}
pub fn drop_markers_in_literals(&mut self, literal_spans: &[(u32, u32)]) {
if literal_spans.is_empty() {
return;
}
let in_literal = |offset: u32| {
literal_spans
.iter()
.any(|&(start, end)| start < offset && offset < end)
};
self.range_markers
.retain(|marker| !in_literal(marker.offset));
let literal_lines: Vec<u32> = self
.line_markers
.iter()
.filter(|marker| in_literal(marker.offset))
.map(|marker| marker.comment_line)
.collect();
self.drop_line_markers(&literal_lines);
}
#[must_use]
pub fn has_markers(&self) -> bool {
!self.range_markers.is_empty() || !self.line_markers.is_empty()
}
pub fn drop_line_markers(&mut self, comment_lines: &[u32]) {
if comment_lines.is_empty() {
return;
}
self.suppressions.retain(|suppression| {
matches!(suppression.scope, SuppressionScope::Range { .. })
|| !comment_lines.contains(&suppression.comment_line)
});
self.unknown_kinds
.retain(|unknown| !comment_lines.contains(&unknown.comment_line));
self.line_markers
.retain(|marker| !comment_lines.contains(&marker.comment_line));
}
fn push_kind_problems(&mut self, marker: &RangeMarker) {
if marker.is_blanket {
self.push_range_problem(marker.comment_line, RangeMarkerProblemKind::MissingKind);
}
for token in &marker.unsupported {
self.range_problems.push(RangeMarkerProblem {
line: marker.comment_line,
kind: RangeMarkerProblemKind::UnsupportedKind,
token: Some(token.clone()),
});
}
}
fn push_range_problem(&mut self, line: u32, kind: RangeMarkerProblemKind) {
self.range_problems.push(RangeMarkerProblem {
line,
kind,
token: None,
});
}
}
#[expect(
clippy::cast_possible_truncation,
reason = "line count and source length are bounded by file size"
)]
fn byte_offset_to_line(source: &str, byte_offset: u32) -> u32 {
let byte_offset = byte_offset as usize;
let prefix = &source[..byte_offset.min(source.len())];
prefix.bytes().filter(|&b| b == b'\n').count() as u32 + 1
}
fn parse_suppression_target_list(rest: &str) -> (Vec<SuppressionTarget>, Vec<String>) {
let mut targets = Vec::new();
let mut unknown = Vec::new();
for token in rest
.split(|c: char| c == ',' || c.is_whitespace())
.filter(|token| !token.is_empty())
{
match parse_suppression_target(token) {
Some(target) => {
if !targets.contains(&target) {
targets.push(target);
}
}
None => {
let owned = token.to_string();
if !unknown.contains(&owned) {
unknown.push(owned);
}
}
}
}
(targets, unknown)
}
fn split_suppression_reason(rest: &str) -> (&str, Option<String>) {
for (idx, _) in rest.match_indices("--") {
let before_ok = idx == 0
|| rest[..idx]
.chars()
.next_back()
.is_some_and(char::is_whitespace);
let after_idx = idx + 2;
let after_ok = after_idx == rest.len()
|| rest[after_idx..]
.chars()
.next()
.is_some_and(char::is_whitespace);
if before_ok && after_ok {
let targets = rest[..idx].trim_end();
let reason = rest[after_idx..].trim();
return (
targets,
if reason.is_empty() {
None
} else {
Some(reason.to_string())
},
);
}
}
(rest, None)
}
fn push_suppressions(parsed: &mut ParsedSuppressions, line: u32, comment_line: u32, rest: &str) {
let (rest, reason) = split_suppression_reason(rest);
if rest.is_empty() {
parsed
.suppressions
.push(Suppression::all(line, comment_line).with_reason(reason));
return;
}
let is_file_level = line == 0;
let (targets, unknown) = parse_suppression_target_list(rest);
parsed
.suppressions
.extend(targets.into_iter().map(|target| Suppression {
line,
comment_line,
target: Some(target),
reason: reason.clone(),
scope: SuppressionScope::for_line(line),
}));
parsed
.unknown_kinds
.extend(unknown.into_iter().map(|token| UnknownSuppressionKind {
comment_line,
is_file_level,
token,
reason: reason.clone(),
}));
}
fn push_range_marker(parsed: &mut ParsedSuppressions, marker: RangeMarkerAt<'_>) {
let (rest, reason) = split_suppression_reason(marker.rest);
let (targets, unknown) = parse_suppression_target_list(rest);
let mut has_range_kind = false;
let mut unsupported = unknown;
for target in targets {
if target == SuppressionTarget::Issue(RANGE_KIND) {
has_range_kind = true;
} else {
unsupported.push(target.token());
}
}
parsed.range_markers.push(RangeMarker {
is_start: marker.is_start,
comment_line: marker.comment_line,
next_line: marker.next_line,
offset: marker.offset,
own_line: marker.own_line,
has_range_kind,
is_blanket: rest.is_empty(),
unsupported,
reason,
});
}
#[derive(Clone, Copy)]
struct RangeMarkerAt<'a> {
is_start: bool,
own_line: bool,
rest: &'a str,
comment_line: u32,
next_line: u32,
offset: u32,
}
#[must_use]
#[expect(
clippy::cast_possible_truncation,
reason = "source length is bounded by file size"
)]
pub(crate) fn parse_suppressions(comments: &[Comment], source: &str) -> ParsedSuppressions {
let mut parsed = ParsedSuppressions::default();
for comment in comments {
let content_span = comment.content_span();
let text = &source
[content_span.start as usize..content_span.end.min(source.len() as u32) as usize];
if !text.contains(MARKER_PREFIX) {
continue;
}
let first_line = byte_offset_to_line(source, comment.span.start);
let at = MarkerSite {
source,
own_line: comment_is_on_own_line(source, comment.span.start, comment.span.end),
};
if comment.is_block() {
let suppressed_line = byte_offset_to_line(source, comment.span.end) + 1;
push_block_markers(&mut parsed, &at, text.lines(), first_line, suppressed_line);
} else if let Some(marker) = match_line_marker(text) {
push_marker(&mut parsed, &at, marker, first_line, first_line + 1);
}
}
parsed.pair_ranges();
parsed
}
struct MarkerSite<'a> {
source: &'a str,
own_line: bool,
}
impl MarkerSite<'_> {
#[expect(
clippy::cast_possible_truncation,
reason = "source length is bounded by file size"
)]
fn offset_of(&self, text: &str) -> u32 {
(text.as_ptr() as usize).saturating_sub(self.source.as_ptr() as usize) as u32
}
}
fn comment_is_on_own_line(source: &str, start: u32, end: u32) -> bool {
let start = (start as usize).min(source.len());
let end = (end as usize).min(source.len());
let before = source[..start].rsplit('\n').next().unwrap_or("");
let after = source[end..].split('\n').next().unwrap_or("");
before.trim().is_empty() && after.trim().is_empty()
}
const MARKER_PREFIX: &str = "fallow-ignore-";
#[derive(Clone, Copy)]
enum Marker<'a> {
File(&'a str),
NextLine(&'a str),
RangeStart(&'a str),
RangeEnd(&'a str),
}
impl<'a> Marker<'a> {
const fn rest(&self) -> &'a str {
match self {
Self::File(rest)
| Self::NextLine(rest)
| Self::RangeStart(rest)
| Self::RangeEnd(rest) => rest,
}
}
}
fn split_marker(text: &str) -> Option<Marker<'_>> {
if let Some(rest) = text.strip_prefix("fallow-ignore-file") {
Some(Marker::File(rest.trim()))
} else if let Some(rest) = text.strip_prefix("fallow-ignore-next-line") {
Some(Marker::NextLine(rest.trim()))
} else if let Some(rest) = strip_marker_word(text, "fallow-ignore-start") {
Some(Marker::RangeStart(rest.trim()))
} else {
strip_marker_word(text, "fallow-ignore-end").map(|rest| Marker::RangeEnd(rest.trim()))
}
}
fn strip_marker_word<'a>(text: &'a str, word: &str) -> Option<&'a str> {
let rest = text.strip_prefix(word)?;
(rest.is_empty() || rest.starts_with(char::is_whitespace)).then_some(rest)
}
fn match_line_marker(text: &str) -> Option<Marker<'_>> {
split_marker(text.trim())
}
fn match_block_marker(line: &str) -> Option<Marker<'_>> {
let text = line
.trim()
.trim_start_matches('*')
.trim_end_matches('*')
.trim();
let marker = split_marker(text)?;
let (targets, _reason) = split_suppression_reason(marker.rest());
let is_marker = targets
.split(|c: char| c == ',' || c.is_whitespace())
.filter(|token| !token.is_empty())
.all(|token| has_issue_kind_shape(token) || parse_suppression_target(token).is_some());
is_marker.then_some(marker)
}
fn has_issue_kind_shape(token: &str) -> bool {
token.contains('-')
&& token
.split('-')
.all(|word| !word.is_empty() && word.bytes().all(|b| b.is_ascii_lowercase()))
}
fn opens_source_block(rest: &str) -> bool {
let rest = rest.trim();
rest.is_empty() || rest == "*" || match_block_marker(rest).is_some()
}
fn push_marker(
parsed: &mut ParsedSuppressions,
site: &MarkerSite<'_>,
marker: Marker<'_>,
comment_line: u32,
suppressed_line: u32,
) {
if let Marker::File(rest) | Marker::NextLine(rest) = marker {
parsed.line_markers.push(LineMarkerAt {
comment_line,
offset: site.offset_of(rest),
});
}
match marker {
Marker::File(rest) => push_suppressions(parsed, 0, comment_line, rest),
Marker::NextLine(rest) => push_suppressions(parsed, suppressed_line, comment_line, rest),
Marker::RangeStart(rest) | Marker::RangeEnd(rest) => push_range_marker(
parsed,
RangeMarkerAt {
is_start: matches!(marker, Marker::RangeStart(_)),
own_line: site.own_line,
rest,
comment_line,
next_line: suppressed_line,
offset: site.offset_of(rest),
},
),
}
}
fn push_block_markers<'a>(
parsed: &mut ParsedSuppressions,
site: &MarkerSite<'_>,
lines: impl Iterator<Item = &'a str>,
first_line: u32,
suppressed_line: u32,
) {
for (line, comment_line) in lines.zip(first_line..) {
if let Some(marker) = match_block_marker(line) {
push_marker(parsed, site, marker, comment_line, suppressed_line);
}
}
}
#[must_use]
pub fn parse_suppressions_from_source(source: &str) -> ParsedSuppressions {
let mut parsed = scan_suppressions_from_source(source);
parsed.pair_ranges();
parsed
}
#[must_use]
#[expect(
clippy::cast_possible_truncation,
reason = "line count is bounded by file size"
)]
pub fn scan_suppressions_from_source(source: &str) -> ParsedSuppressions {
let mut parsed = ParsedSuppressions::default();
let lines: Vec<&str> = source.lines().collect();
let site = MarkerSite {
source,
own_line: true,
};
let shared_line = MarkerSite {
source,
own_line: false,
};
let mut idx = 0;
while idx < lines.len() {
let comment_line = (idx as u32) + 1;
let trimmed = lines[idx].trim();
if let Some(rest) = trimmed.strip_prefix("//") {
if let Some(marker) = match_line_marker(rest) {
push_marker(&mut parsed, &site, marker, comment_line, comment_line + 1);
}
} else if let Some(rest) = trimmed.strip_prefix("<!--") {
if let Some(marker) = rest.strip_suffix("-->").and_then(match_line_marker) {
push_marker(&mut parsed, &site, marker, comment_line, comment_line + 1);
} else {
push_shared_line_range_marker(&mut parsed, &shared_line, trimmed, comment_line);
}
} else if let Some(rest) = trimmed.strip_prefix("/*") {
if rest
.find("*/")
.is_some_and(|end| end + "*/".len() != rest.len())
{
push_shared_line_range_marker(&mut parsed, &shared_line, trimmed, comment_line);
}
idx = scan_source_block(&mut parsed, &site, &lines, idx, rest);
} else {
push_shared_line_range_marker(&mut parsed, &shared_line, trimmed, comment_line);
}
idx += 1;
}
parsed
}
fn push_shared_line_range_marker(
parsed: &mut ParsedSuppressions,
site: &MarkerSite<'_>,
line: &str,
comment_line: u32,
) {
let Some(idx) = line.find(MARKER_PREFIX) else {
return;
};
let before = line[..idx].trim_end();
if !["//", "/*", "/**", "<!--"]
.iter()
.any(|opener| before.ends_with(opener))
{
return;
}
let text = &line[idx..];
let text = text
.find("*/")
.or_else(|| text.find("-->"))
.map_or(text, |end| &text[..end]);
if let Some(marker @ (Marker::RangeStart(_) | Marker::RangeEnd(_))) =
split_marker(text.trim_end())
{
push_marker(parsed, site, marker, comment_line, comment_line + 1);
}
}
#[expect(
clippy::cast_possible_truncation,
reason = "line count is bounded by file size"
)]
fn scan_source_block(
parsed: &mut ParsedSuppressions,
site: &MarkerSite<'_>,
lines: &[&str],
idx: usize,
rest: &str,
) -> usize {
const BLOCK_END: &str = "*/";
let comment_line = (idx as u32) + 1;
if let Some(end) = rest.find(BLOCK_END) {
if end + BLOCK_END.len() == rest.len() {
let content = std::iter::once(&rest[..end]);
push_block_markers(parsed, site, content, comment_line, comment_line + 1);
}
return idx;
}
if !opens_source_block(rest) {
return idx;
}
let Some(close_idx) = (idx + 1..lines.len()).find(|&i| lines[i].contains(BLOCK_END)) else {
return idx;
};
for (inner_idx, line) in lines.iter().enumerate().take(close_idx).skip(idx + 1) {
let inner_line = (inner_idx as u32) + 1;
if let Some(marker) = line.trim().strip_prefix("//").and_then(match_line_marker) {
push_marker(parsed, site, marker, inner_line, inner_line + 1);
}
}
let close_line = lines[close_idx];
let content = std::iter::once(rest)
.chain(lines[idx + 1..close_idx].iter().copied())
.chain(std::iter::once(
&close_line[..close_line.find(BLOCK_END).unwrap_or(close_line.len())],
));
let suppressed_line = (close_idx as u32) + 2;
push_block_markers(parsed, site, content, comment_line, suppressed_line);
close_idx
}
#[cfg(test)]
#[path = "suppress_range_tests.rs"]
mod range_tests;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_file_wide_suppression() {
let source = "// fallow-ignore-file\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert!(suppressions[0].issue_kind_target().is_none());
}
#[test]
fn parse_file_wide_suppression_with_kind() {
let source = "// fallow-ignore-file unused-export\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_next_line_suppression() {
let source =
"import { x } from './x';\n// fallow-ignore-next-line\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 3); assert!(suppressions[0].issue_kind_target().is_none());
}
#[test]
fn parse_next_line_suppression_with_kind() {
let source = "// fallow-ignore-next-line unused-export\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 2);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_next_line_suppression_with_reason() {
let source = "// fallow-ignore-next-line unused-export -- legacy public API\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].reason.as_deref(), Some("legacy public API"));
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_blanket_file_suppression_with_reason() {
let source = "// fallow-ignore-file -- generated route map\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert!(suppressions[0].issue_kind_target().is_none());
assert_eq!(
suppressions[0].reason.as_deref(),
Some("generated route map")
);
}
#[test]
fn parse_next_line_suppression_with_comma_kind_list() {
let source =
"// fallow-ignore-next-line unused-export, complexity\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 2);
assert_eq!(suppressions[0].line, 2);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert_eq!(suppressions[1].line, 2);
assert_eq!(
suppressions[1].issue_kind_target(),
Some(IssueKind::Complexity)
);
}
#[test]
fn parse_next_line_suppression_with_space_kind_list() {
let source = "// fallow-ignore-next-line unused-export complexity\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 2);
assert_eq!(suppressions[0].line, 2);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert_eq!(suppressions[1].line, 2);
assert_eq!(
suppressions[1].issue_kind_target(),
Some(IssueKind::Complexity)
);
}
#[test]
fn parse_scoped_policy_suppression() {
let source =
"// fallow-ignore-next-line policy-violation:team-policy/no-child-process\nexec();\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 2);
let target = suppressions[0]
.policy_rule_target()
.expect("scoped policy target should parse");
assert_eq!(target.pack, "team-policy");
assert_eq!(target.rule_id, "no-child-process");
}
#[test]
fn parse_scoped_policy_suppression_mixed_with_regular_kind() {
let source = "// fallow-ignore-next-line policy-violation:team-policy/no-child-process, unused-export\nexec();\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 2);
assert!(suppressions[0].policy_rule_target().is_some());
assert_eq!(
suppressions[1].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_malformed_scoped_policy_suppression_as_unknown() {
let source =
"// fallow-ignore-next-line policy-violation:team-policy/no:child-process\nexec();\n";
let parsed = parse_suppressions_from_source(source);
assert!(parsed.suppressions.is_empty());
assert_eq!(parsed.unknown_kinds.len(), 1);
assert_eq!(
parsed.unknown_kinds[0].token,
"policy-violation:team-policy/no:child-process"
);
}
#[test]
fn parse_unknown_kind_surfaces_as_unknown() {
let source = "// fallow-ignore-next-line typo-kind\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert!(
parsed.suppressions.is_empty(),
"no known kinds on the marker, so no suppression should be recorded"
);
assert_eq!(parsed.unknown_kinds.len(), 1);
assert_eq!(parsed.unknown_kinds[0].token, "typo-kind");
assert_eq!(parsed.unknown_kinds[0].comment_line, 1);
assert!(!parsed.unknown_kinds[0].is_file_level);
}
#[test]
fn parse_partial_accept_known_kinds_recorded() {
let source = "// fallow-ignore-next-line unused-export, complexity-typo -- tracked migration\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].line, 2);
assert_eq!(
parsed.suppressions[0].reason.as_deref(),
Some("tracked migration")
);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert_eq!(parsed.unknown_kinds.len(), 1);
assert_eq!(parsed.unknown_kinds[0].token, "complexity-typo");
assert_eq!(
parsed.unknown_kinds[0].reason.as_deref(),
Some("tracked migration")
);
assert_eq!(parsed.unknown_kinds[0].comment_line, 1);
assert!(!parsed.unknown_kinds[0].is_file_level);
}
#[test]
fn parse_multiple_unknown_kinds_each_recorded() {
let source = "// fallow-ignore-next-line typo-a, typo-b typo-c\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert!(parsed.suppressions.is_empty());
assert_eq!(parsed.unknown_kinds.len(), 3);
let tokens: Vec<&str> = parsed
.unknown_kinds
.iter()
.map(|u| u.token.as_str())
.collect();
assert_eq!(tokens, vec!["typo-a", "typo-b", "typo-c"]);
}
#[test]
fn parse_unknown_kind_file_level_carries_is_file_level() {
let source = "// fallow-ignore-file typo-kind\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert!(parsed.suppressions.is_empty());
assert_eq!(parsed.unknown_kinds.len(), 1);
assert_eq!(parsed.unknown_kinds[0].token, "typo-kind");
assert!(parsed.unknown_kinds[0].is_file_level);
}
#[test]
fn parse_unknown_kind_deduplicates_repeats() {
let source = "// fallow-ignore-next-line typo, typo\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert_eq!(parsed.unknown_kinds.len(), 1);
}
#[test]
fn parse_oxc_comments() {
use oxc_allocator::Allocator;
use oxc_parser::Parser;
use oxc_span::SourceType;
let source = "// fallow-ignore-file\n// fallow-ignore-next-line unused-export\nexport const foo = 1;\nexport const bar = 2;\n";
let allocator = Allocator::default();
let parser_return = Parser::new(&allocator, source, SourceType::mjs()).parse();
let suppressions = parse_suppressions(&parser_return.program.comments, source).suppressions;
assert_eq!(suppressions.len(), 2);
assert_eq!(suppressions[0].line, 0);
assert!(suppressions[0].issue_kind_target().is_none());
assert_eq!(suppressions[1].line, 3);
assert_eq!(
suppressions[1].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_block_comment_suppression() {
let source = "/* fallow-ignore-file */\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert!(suppressions[0].issue_kind_target().is_none());
}
#[test]
fn parse_html_comment_file_suppression() {
let source = "<!-- fallow-ignore-file complexity -->\n@if (enabled) { <p /> }\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::Complexity)
);
}
#[test]
fn parse_block_comment_next_line_suppression() {
let source = "/* fallow-ignore-next-line unused-export */\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 2);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_html_comment_next_line_suppression() {
let source = "<!-- fallow-ignore-next-line complexity -->\n@if (enabled) { <p /> }\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 2);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::Complexity)
);
}
#[test]
fn parse_multiple_suppressions_on_adjacent_lines() {
let source = "// fallow-ignore-next-line unused-export\n// fallow-ignore-next-line unused-type\nexport const foo = 1;\nexport type Bar = string;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 2);
assert_eq!(suppressions[0].line, 2);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert_eq!(suppressions[1].line, 3);
assert_eq!(
suppressions[1].issue_kind_target(),
Some(IssueKind::UnusedType)
);
}
#[test]
fn parse_file_wide_and_next_line_combined() {
let source = "// fallow-ignore-file unused-file\n// fallow-ignore-next-line unused-export\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 2);
assert_eq!(suppressions[0].line, 0);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedFile)
);
assert_eq!(suppressions[1].line, 3);
assert_eq!(
suppressions[1].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_suppression_all_issue_kinds() {
let kinds = [
("unused-file", IssueKind::UnusedFile),
("unused-export", IssueKind::UnusedExport),
("unused-type", IssueKind::UnusedType),
("unused-dependency", IssueKind::UnusedDependency),
("unused-dev-dependency", IssueKind::UnusedDevDependency),
("unused-enum-member", IssueKind::UnusedEnumMember),
("unused-class-member", IssueKind::UnusedClassMember),
("unresolved-import", IssueKind::UnresolvedImport),
("unlisted-dependency", IssueKind::UnlistedDependency),
("duplicate-export", IssueKind::DuplicateExport),
("duplicate-export-alias", IssueKind::DuplicateExportAlias),
("duplicate-export-aliases", IssueKind::DuplicateExportAlias),
("code-duplication", IssueKind::CodeDuplication),
("circular-dependency", IssueKind::CircularDependency),
("circular-dependencies", IssueKind::CircularDependency),
];
for (token, expected_kind) in &kinds {
let source = format!("// fallow-ignore-file {token}\nexport const foo = 1;\n");
let suppressions = parse_suppressions_from_source(&source).suppressions;
assert_eq!(suppressions.len(), 1, "Expected 1 suppression for {token}");
assert_eq!(suppressions[0].issue_kind_target(), Some(*expected_kind));
}
}
#[test]
fn parse_block_comment_with_whitespace() {
let source = "/* fallow-ignore-file */\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert!(suppressions[0].issue_kind_target().is_none());
}
#[test]
fn parse_empty_source_no_suppressions() {
let suppressions = parse_suppressions_from_source("").suppressions;
assert!(suppressions.is_empty());
}
#[test]
fn parse_no_suppression_comments() {
let source = "// regular comment\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert!(suppressions.is_empty());
}
#[test]
fn parse_suppression_not_at_line_start_ignored() {
let source = "export const foo = 1; // fallow-ignore-file\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert!(
suppressions.is_empty(),
"Inline comment after code should not be parsed as suppression"
);
}
#[test]
fn parse_block_comment_without_closing_ignored() {
let source = "/* fallow-ignore-file\nexport const foo = 1;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert!(suppressions.is_empty());
}
#[test]
fn byte_offset_to_line_first_byte() {
assert_eq!(byte_offset_to_line("abc\ndef\n", 0), 1);
}
#[test]
fn byte_offset_to_line_second_line() {
assert_eq!(byte_offset_to_line("abc\ndef\n", 4), 2);
}
#[test]
fn byte_offset_to_line_beyond_source() {
assert_eq!(byte_offset_to_line("abc\n", 100), 2);
}
#[test]
fn parse_oxc_block_comment_suppression() {
use oxc_allocator::Allocator;
use oxc_parser::Parser;
use oxc_span::SourceType;
let source = "/* fallow-ignore-file unused-file */\nexport const foo = 1;\n";
let allocator = Allocator::default();
let parser_return = Parser::new(&allocator, source, SourceType::mjs()).parse();
let suppressions = parse_suppressions(&parser_return.program.comments, source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(suppressions[0].line, 0);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedFile)
);
}
#[test]
fn parse_oxc_multiline_block_comment_suppresses_line_after_comment_end() {
use oxc_allocator::Allocator;
use oxc_parser::Parser;
use oxc_span::SourceType;
let source = "/* fallow-ignore-next-line unused-export\n kept for the legacy import path */\nexport const foo = 1;\n";
let allocator = Allocator::default();
let parser_return = Parser::new(&allocator, source, SourceType::mjs()).parse();
let parsed = parse_suppressions(&parser_return.program.comments, source);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(
parsed.suppressions[0].line, 3,
"suppression must land on the line after `*/`, not inside the comment"
);
assert_eq!(parsed.suppressions[0].comment_line, 1);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert!(
parsed.unknown_kinds.is_empty(),
"prose after the marker line must not be tokenized into unknown kinds"
);
}
#[test]
fn parse_oxc_unknown_kind_surfaces_as_unknown() {
use oxc_allocator::Allocator;
use oxc_parser::Parser;
use oxc_span::SourceType;
let source = "// fallow-ignore-next-line nonexistent-kind\nexport const foo = 1;\n";
let allocator = Allocator::default();
let parser_return = Parser::new(&allocator, source, SourceType::mjs()).parse();
let parsed = parse_suppressions(&parser_return.program.comments, source);
assert!(parsed.suppressions.is_empty());
assert_eq!(parsed.unknown_kinds.len(), 1);
assert_eq!(parsed.unknown_kinds[0].token, "nonexistent-kind");
}
fn parse_oxc(source: &str) -> ParsedSuppressions {
use oxc_allocator::Allocator;
use oxc_parser::Parser;
use oxc_span::SourceType;
let allocator = Allocator::default();
let parser_return = Parser::new(&allocator, source, SourceType::mjs()).parse();
parse_suppressions(&parser_return.program.comments, source)
}
#[test]
fn parse_oxc_single_line_jsdoc_next_line_suppression() {
let parsed =
parse_oxc("/** fallow-ignore-next-line unused-export */\nexport const foo = 1;\n");
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].line, 2);
assert_eq!(parsed.suppressions[0].comment_line, 1);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert!(parsed.unknown_kinds.is_empty());
}
#[test]
fn parse_oxc_multi_line_jsdoc_next_line_suppression() {
let parsed = parse_oxc(
"/**\n * fallow-ignore-next-line unused-export\n */\nexport const foo = 1;\n",
);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(
parsed.suppressions[0].line, 4,
"suppression must land on the line after `*/`"
);
assert_eq!(
parsed.suppressions[0].comment_line, 2,
"comment_line must point at the marker line"
);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert!(parsed.unknown_kinds.is_empty());
}
#[test]
fn parse_oxc_multi_line_jsdoc_marker_after_prose() {
let parsed = parse_oxc(
"/**\n * Kept for the legacy import path.\n * fallow-ignore-next-line unused-export -- legacy\n * More prose.\n */\nexport const foo = 1;\n",
);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].line, 6);
assert_eq!(parsed.suppressions[0].comment_line, 3);
assert_eq!(parsed.suppressions[0].reason.as_deref(), Some("legacy"));
assert!(
parsed.unknown_kinds.is_empty(),
"prose lines must not be tokenized into unknown kinds"
);
}
#[test]
fn parse_oxc_jsdoc_file_suppression() {
let parsed = parse_oxc("/** fallow-ignore-file unused-export */\nexport const foo = 1;\n");
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].line, 0);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
}
#[test]
fn parse_oxc_jsdoc_unknown_kind_surfaces_as_unknown() {
let parsed = parse_oxc(
"/**\n * fallow-ignore-next-line nonexistent-kind\n */\nexport const foo = 1;\n",
);
assert!(parsed.suppressions.is_empty());
assert_eq!(parsed.unknown_kinds.len(), 1);
assert_eq!(parsed.unknown_kinds[0].token, "nonexistent-kind");
assert_eq!(parsed.unknown_kinds[0].comment_line, 2);
}
#[test]
fn parse_oxc_line_comment_marker_after_text_ignored() {
let parsed =
parse_oxc("// see fallow-ignore-next-line unused-export\nexport const foo = 1;\n");
assert!(parsed.suppressions.is_empty());
assert!(parsed.unknown_kinds.is_empty());
}
#[test]
fn parse_oxc_jsdoc_marker_inside_prose_ignored() {
let parsed = parse_oxc(
"/** Do not use fallow-ignore-next-line here */\nexport const foo = 1;\n/**\n * Do not use fallow-ignore-file here.\n */\nexport const bar = 2;\n",
);
assert!(parsed.suppressions.is_empty());
assert!(parsed.unknown_kinds.is_empty());
}
#[test]
fn parse_source_single_line_jsdoc_suppressions() {
let parsed = parse_suppressions_from_source(
"/** fallow-ignore-file code-duplication */\n/** fallow-ignore-next-line unused-export */\nexport const foo = 1;\n",
);
assert_eq!(parsed.suppressions.len(), 2);
assert_eq!(parsed.suppressions[0].line, 0);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::CodeDuplication)
);
assert_eq!(parsed.suppressions[1].line, 3);
assert_eq!(
parsed.suppressions[1].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert!(parsed.unknown_kinds.is_empty());
}
#[test]
fn parse_source_multi_line_jsdoc_file_suppression() {
let parsed = parse_suppressions_from_source(
"/**\n * fallow-ignore-file code-duplication\n */\nexport const foo = 1;\n",
);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].line, 0);
assert_eq!(parsed.suppressions[0].comment_line, 2);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::CodeDuplication)
);
}
#[test]
fn parse_source_multi_line_jsdoc_next_line_targets_line_after_close() {
let parsed = parse_suppressions_from_source(
"/**\n * Kept for the legacy path.\n * fallow-ignore-next-line unused-export\n */\nexport const foo = 1;\n",
);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].line, 5);
assert_eq!(parsed.suppressions[0].comment_line, 3);
assert!(parsed.unknown_kinds.is_empty());
}
#[test]
fn parse_source_block_comment_with_code_after_close_is_scanned_once() {
let parsed = parse_suppressions_from_source(
"/*\n * fallow-ignore-next-line unused-export\n */\nexport const foo = 1;\n// fallow-ignore-next-line unused-type\nexport type Bar = 1;\n",
);
let lines: Vec<u32> = parsed.suppressions.iter().map(|s| s.line).collect();
assert_eq!(lines, vec![4, 6]);
}
#[test]
fn jsdoc_wrapped_prose_line_is_not_a_marker() {
let source = "/**\n * Use the comment below to hide a finding:\n * fallow-ignore-next-line is how you hide a finding.\n */\nexport const foo = 1;\n";
for parsed in [parse_oxc(source), parse_suppressions_from_source(source)] {
assert!(parsed.suppressions.is_empty(), "{:?}", parsed.suppressions);
assert!(
parsed.unknown_kinds.is_empty(),
"{:?}",
parsed.unknown_kinds
);
}
}
#[test]
fn jsdoc_marker_reason_prose_does_not_fail_the_target_rule() {
let source = "/**\n * fallow-ignore-next-line unused-export -- kept for the legacy path, see notes.\n */\nexport const foo = 1;\n";
for parsed in [parse_oxc(source), parse_suppressions_from_source(source)] {
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::UnusedExport)
);
assert_eq!(
parsed.suppressions[0].reason.as_deref(),
Some("kept for the legacy path, see notes.")
);
assert!(parsed.unknown_kinds.is_empty());
}
let parsed = parse_oxc(
"/**\n * fallow-ignore-next-line -- kept for the legacy path\n */\nexport const foo = 1;\n",
);
assert_eq!(parsed.suppressions.len(), 1);
assert_eq!(parsed.suppressions[0].target, None);
assert_eq!(
parsed.suppressions[0].reason.as_deref(),
Some("kept for the legacy path")
);
}
#[test]
fn jsdoc_prose_line_with_hyphenated_first_word_is_not_a_marker() {
let source = "/**\n * Cache keys follow the\n * fallow-ignore-next-line well-known pattern for caches.\n */\nexport const foo = 1;\n";
for parsed in [parse_oxc(source), parse_suppressions_from_source(source)] {
assert!(parsed.suppressions.is_empty(), "{:?}", parsed.suppressions);
assert!(
parsed.unknown_kinds.is_empty(),
"{:?}",
parsed.unknown_kinds
);
}
}
#[test]
fn jsdoc_marker_with_typo_kind_still_warns() {
let source = "/**\n * fallow-ignore-next-line unused-exprt\n */\nexport const foo = 1;\n";
for parsed in [parse_oxc(source), parse_suppressions_from_source(source)] {
let tokens: Vec<&str> = parsed
.unknown_kinds
.iter()
.map(|u| u.token.as_str())
.collect();
assert_eq!(tokens, vec!["unused-exprt"]);
}
}
#[test]
fn source_scan_unclosed_opener_in_string_keeps_later_marker() {
let source = "const glob = `\n/* glob\n`;\n// fallow-ignore-file code-duplication\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert_eq!(parsed.suppressions.len(), 1, "{:?}", parsed.suppressions);
assert_eq!(parsed.suppressions[0].line, 0);
assert_eq!(parsed.suppressions[0].comment_line, 4);
assert_eq!(
parsed.suppressions[0].issue_kind_target(),
Some(IssueKind::CodeDuplication)
);
}
#[test]
fn source_scan_comment_shape_in_string_is_not_a_marker() {
let source = "const doc = `\n/* start\n * fallow-ignore-file code-duplication\n */\n`;\nexport const foo = 1;\n";
let parsed = parse_suppressions_from_source(source);
assert!(parsed.suppressions.is_empty(), "{:?}", parsed.suppressions);
}
#[test]
fn source_scan_unclosed_block_mid_file_keeps_later_line_marker() {
let source = "export const a = 1;\n/**\n * never closed\n// fallow-ignore-next-line unused-export\nexport const b = 2;\n";
let parsed = parse_suppressions_from_source(source);
assert_eq!(parsed.suppressions.len(), 1, "{:?}", parsed.suppressions);
assert_eq!(parsed.suppressions[0].line, 5);
assert_eq!(parsed.suppressions[0].comment_line, 4);
}
#[test]
fn source_scan_line_marker_inside_candidate_block_counts() {
let source = "/**\n// fallow-ignore-next-line unused-export\nexport const b = 2;\nconst end = \"*/\";\n";
let parsed = parse_suppressions_from_source(source);
assert_eq!(parsed.suppressions.len(), 1, "{:?}", parsed.suppressions);
assert_eq!(parsed.suppressions[0].line, 3);
assert_eq!(parsed.suppressions[0].comment_line, 2);
}
#[test]
fn jsdoc_block_with_two_marker_lines_records_both() {
let source = "/**\n * fallow-ignore-file code-duplication\n * fallow-ignore-next-line unused-export\n */\nexport const foo = 1;\n";
for parsed in [parse_oxc(source), parse_suppressions_from_source(source)] {
let found: Vec<(u32, Option<IssueKind>)> = parsed
.suppressions
.iter()
.map(|s| (s.line, s.issue_kind_target()))
.collect();
assert_eq!(
found,
vec![
(0, Some(IssueKind::CodeDuplication)),
(5, Some(IssueKind::UnusedExport)),
]
);
}
}
#[test]
fn line_comment_does_not_strip_stars() {
let source = "//* fallow-ignore-next-line unused-export\nexport const foo = 1;\n// fallow-ignore-next-line unused-export*\nexport const bar = 1;\n";
for parsed in [parse_oxc(source), parse_suppressions_from_source(source)] {
assert!(parsed.suppressions.is_empty(), "{:?}", parsed.suppressions);
let tokens: Vec<&str> = parsed
.unknown_kinds
.iter()
.map(|u| u.token.as_str())
.collect();
assert_eq!(tokens, vec!["unused-export*"]);
}
}
#[test]
fn duplicate_export_token_does_not_suppress_alias_kind() {
let source = "// fallow-ignore-next-line duplicate-export\nexport default a;\n";
let suppressions = parse_suppressions_from_source(source).suppressions;
assert_eq!(suppressions.len(), 1);
assert_eq!(
suppressions[0].issue_kind_target(),
Some(IssueKind::DuplicateExport)
);
assert!(!suppressions[0].matches_issue_kind(2, IssueKind::DuplicateExportAlias));
}
}