Skip to content

Avoid generating diagnostics with per-file ignores #18801

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
ntBre merged 12 commits into from
Jun 20, 2025
Merged

Avoid generating diagnostics with per-file ignores #18801

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
12 commits
Select commit Hold shift + click to select a range
e372a2c
use Checker::enabled where possible
ntBre Jun 19, 2025
6bbd70b
defer to LintContext::enabled in Checker
ntBre Jun 19, 2025
42f5315
store just a RuleTable, not the whole Settings
ntBre Jun 19, 2025
fd774da
prefer LintContext methods to accessing rules directly
ntBre Jun 19, 2025
c3af9ce
construct LintContext's SourceFile internally
ntBre Jun 19, 2025
ffbab4b
apply per-file ignores in LintContext
ntBre Jun 19, 2025
697781b
always clone RuleTable, restore const
ntBre Jun 19, 2025
534e2a6
diagnostics -> context in check_path
ntBre Jun 19, 2025
4a8ecbe
update LintContext method names
ntBre Jun 19, 2025
a1d9b9e
update Checker method names too
ntBre Jun 19, 2025
deb304e
move empty ignores check to ignores_from_path
ntBre Jun 20, 2025
0e7769f
restore (unused) LinterSettings on LintContext
ntBre Jun 20, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 15 additions & 15 deletions crates/ruff_linter/src/checkers/ast/analyze/bindings.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ use crate::rules::{

/// Run lint rules over the [`Binding`]s.
pub(crate) fn bindings(checker: &Checker) {
if !checker.any_enabled(&[
if !checker.any_rule_enabled(&[
Rule::AssignmentInAssert,
Rule::InvalidAllFormat,
Rule::InvalidAllObject,
Expand All @@ -30,7 +30,7 @@ pub(crate) fn bindings(checker: &Checker) {
}

for (binding_id, binding) in checker.semantic.bindings.iter_enumerated() {
if checker.enabled(Rule::UnusedVariable) {
if checker.is_rule_enabled(Rule::UnusedVariable) {
if binding.kind.is_bound_exception()
&& binding.is_unused()
&& !checker
Expand All @@ -54,47 +54,47 @@ pub(crate) fn bindings(checker: &Checker) {
});
}
}
if checker.enabled(Rule::InvalidAllFormat) {
if checker.is_rule_enabled(Rule::InvalidAllFormat) {
pylint::rules::invalid_all_format(checker, binding);
}
if checker.enabled(Rule::InvalidAllObject) {
if checker.is_rule_enabled(Rule::InvalidAllObject) {
pylint::rules::invalid_all_object(checker, binding);
}
if checker.enabled(Rule::NonAsciiName) {
if checker.is_rule_enabled(Rule::NonAsciiName) {
pylint::rules::non_ascii_name(checker, binding);
}
if checker.enabled(Rule::UnconventionalImportAlias) {
if checker.is_rule_enabled(Rule::UnconventionalImportAlias) {
flake8_import_conventions::rules::unconventional_import_alias(
checker,
binding,
&checker.settings.flake8_import_conventions.aliases,
);
}
if checker.enabled(Rule::UnaliasedCollectionsAbcSetImport) {
if checker.is_rule_enabled(Rule::UnaliasedCollectionsAbcSetImport) {
flake8_pyi::rules::unaliased_collections_abc_set_import(checker, binding);
}
if !checker.source_type.is_stub() && checker.enabled(Rule::UnquotedTypeAlias) {
if !checker.source_type.is_stub() && checker.is_rule_enabled(Rule::UnquotedTypeAlias) {
flake8_type_checking::rules::unquoted_type_alias(checker, binding);
}
if checker.enabled(Rule::UnsortedDunderSlots) {
if checker.is_rule_enabled(Rule::UnsortedDunderSlots) {
ruff::rules::sort_dunder_slots(checker, binding);
}
if checker.enabled(Rule::UsedDummyVariable) {
if checker.is_rule_enabled(Rule::UsedDummyVariable) {
ruff::rules::used_dummy_variable(checker, binding, binding_id);
}
if checker.enabled(Rule::AssignmentInAssert) {
if checker.is_rule_enabled(Rule::AssignmentInAssert) {
ruff::rules::assignment_in_assert(checker, binding);
}
if checker.enabled(Rule::PytestUnittestRaisesAssertion) {
if checker.is_rule_enabled(Rule::PytestUnittestRaisesAssertion) {
flake8_pytest_style::rules::unittest_raises_assertion_binding(checker, binding);
}
if checker.enabled(Rule::ForLoopWrites) {
if checker.is_rule_enabled(Rule::ForLoopWrites) {
refurb::rules::for_loop_writes_binding(checker, binding);
}
if checker.enabled(Rule::CustomTypeVarForSelf) {
if checker.is_rule_enabled(Rule::CustomTypeVarForSelf) {
flake8_pyi::rules::custom_type_var_instead_of_self(checker, binding);
}
if checker.enabled(Rule::PrivateTypeParameter) {
if checker.is_rule_enabled(Rule::PrivateTypeParameter) {
pyupgrade::rules::private_type_parameter(checker, binding);
}
}
Expand Down
4 changes: 2 additions & 2 deletions crates/ruff_linter/src/checkers/ast/analyze/comprehension.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,10 +6,10 @@ use crate::rules::{flake8_simplify, refurb};

/// Run lint rules over a [`Comprehension`] syntax nodes.
pub(crate) fn comprehension(comprehension: &Comprehension, checker: &Checker) {
if checker.enabled(Rule::InDictKeys) {
if checker.is_rule_enabled(Rule::InDictKeys) {
flake8_simplify::rules::key_in_dict_comprehension(checker, comprehension);
}
if checker.enabled(Rule::ReadlinesInFor) {
if checker.is_rule_enabled(Rule::ReadlinesInFor) {
refurb::rules::readlines_in_comprehension(checker, comprehension);
}
}
18 changes: 9 additions & 9 deletions crates/ruff_linter/src/checkers/ast/analyze/deferred_for_loops.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,31 +14,31 @@ pub(crate) fn deferred_for_loops(checker: &mut Checker) {
let Stmt::For(stmt_for) = checker.semantic.current_statement() else {
unreachable!("Expected Stmt::For");
};
if checker.enabled(Rule::UnusedLoopControlVariable) {
if checker.is_rule_enabled(Rule::UnusedLoopControlVariable) {
flake8_bugbear::rules::unused_loop_control_variable(checker, stmt_for);
}
if checker.enabled(Rule::IncorrectDictIterator) {
if checker.is_rule_enabled(Rule::IncorrectDictIterator) {
perflint::rules::incorrect_dict_iterator(checker, stmt_for);
}
if checker.enabled(Rule::YieldInForLoop) {
if checker.is_rule_enabled(Rule::YieldInForLoop) {
pyupgrade::rules::yield_in_for_loop(checker, stmt_for);
}
if checker.enabled(Rule::UnnecessaryEnumerate) {
if checker.is_rule_enabled(Rule::UnnecessaryEnumerate) {
refurb::rules::unnecessary_enumerate(checker, stmt_for);
}
if checker.enabled(Rule::EnumerateForLoop) {
if checker.is_rule_enabled(Rule::EnumerateForLoop) {
flake8_simplify::rules::enumerate_for_loop(checker, stmt_for);
}
if checker.enabled(Rule::LoopIteratorMutation) {
if checker.is_rule_enabled(Rule::LoopIteratorMutation) {
flake8_bugbear::rules::loop_iterator_mutation(checker, stmt_for);
}
if checker.enabled(Rule::DictIndexMissingItems) {
if checker.is_rule_enabled(Rule::DictIndexMissingItems) {
pylint::rules::dict_index_missing_items(checker, stmt_for);
}
if checker.enabled(Rule::ManualDictComprehension) {
if checker.is_rule_enabled(Rule::ManualDictComprehension) {
perflint::rules::manual_dict_comprehension(checker, stmt_for);
}
if checker.enabled(Rule::ManualListComprehension) {
if checker.is_rule_enabled(Rule::ManualListComprehension) {
perflint::rules::manual_list_comprehension(checker, stmt_for);
}
}
Expand Down
6 changes: 3 additions & 3 deletions crates/ruff_linter/src/checkers/ast/analyze/deferred_lambdas.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,13 +15,13 @@ pub(crate) fn deferred_lambdas(checker: &mut Checker) {
unreachable!("Expected Expr::Lambda");
};

if checker.enabled(Rule::UnnecessaryLambda) {
if checker.is_rule_enabled(Rule::UnnecessaryLambda) {
pylint::rules::unnecessary_lambda(checker, lambda);
}
if checker.enabled(Rule::ReimplementedContainerBuiltin) {
if checker.is_rule_enabled(Rule::ReimplementedContainerBuiltin) {
flake8_pie::rules::reimplemented_container_builtin(checker, lambda);
}
if checker.enabled(Rule::BuiltinLambdaArgumentShadowing) {
if checker.is_rule_enabled(Rule::BuiltinLambdaArgumentShadowing) {
flake8_builtins::rules::builtin_lambda_argument_shadowing(checker, lambda);
}
}
Expand Down
60 changes: 30 additions & 30 deletions crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,7 +14,7 @@ use crate::rules::{

/// Run lint rules over all deferred scopes in the [`SemanticModel`].
pub(crate) fn deferred_scopes(checker: &Checker) {
if !checker.any_enabled(&[
if !checker.any_rule_enabled(&[
Rule::AsyncioDanglingTask,
Rule::BadStaticmethodArgument,
Rule::BuiltinAttributeShadowing,
Expand Down Expand Up @@ -58,7 +58,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
// used at runtime, then by default, we avoid flagging any other
// imports from that model as typing-only.
let enforce_typing_only_imports = !checker.source_type.is_stub()
&& checker.any_enabled(&[
&& checker.any_rule_enabled(&[
Rule::TypingOnlyFirstPartyImport,
Rule::TypingOnlyStandardLibraryImport,
Rule::TypingOnlyThirdPartyImport,
Expand Down Expand Up @@ -89,11 +89,11 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
for scope_id in checker.analyze.scopes.iter().rev().copied() {
let scope = &checker.semantic.scopes[scope_id];

if checker.enabled(Rule::UndefinedLocal) {
if checker.is_rule_enabled(Rule::UndefinedLocal) {
pyflakes::rules::undefined_local(checker, scope_id, scope);
}

if checker.enabled(Rule::GlobalVariableNotAssigned) {
if checker.is_rule_enabled(Rule::GlobalVariableNotAssigned) {
for (name, binding_id) in scope.bindings() {
let binding = checker.semantic.binding(binding_id);
// If the binding is a `global`, then it's a top-level `global` that was never
Expand Down Expand Up @@ -123,7 +123,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
}
}

if checker.enabled(Rule::RedefinedArgumentFromLocal) {
if checker.is_rule_enabled(Rule::RedefinedArgumentFromLocal) {
for (name, binding_id) in scope.bindings() {
for shadow in checker.semantic.shadowed_bindings(scope_id, binding_id) {
let binding = &checker.semantic.bindings[shadow.binding_id()];
Expand Down Expand Up @@ -156,7 +156,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
}
}

if checker.enabled(Rule::ImportShadowedByLoopVar) {
if checker.is_rule_enabled(Rule::ImportShadowedByLoopVar) {
for (name, binding_id) in scope.bindings() {
for shadow in checker.semantic.shadowed_bindings(scope_id, binding_id) {
// If the shadowing binding isn't a loop variable, abort.
Expand Down Expand Up @@ -197,7 +197,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
}
}

if checker.enabled(Rule::RedefinedWhileUnused) {
if checker.is_rule_enabled(Rule::RedefinedWhileUnused) {
// Index the redefined bindings by statement.
let mut redefinitions = FxHashMap::default();

Expand Down Expand Up @@ -353,43 +353,43 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
if checker.source_type.is_stub()
|| matches!(scope.kind, ScopeKind::Module | ScopeKind::Function(_))
{
if checker.enabled(Rule::UnusedPrivateTypeVar) {
if checker.is_rule_enabled(Rule::UnusedPrivateTypeVar) {
flake8_pyi::rules::unused_private_type_var(checker, scope);
}
if checker.enabled(Rule::UnusedPrivateProtocol) {
if checker.is_rule_enabled(Rule::UnusedPrivateProtocol) {
flake8_pyi::rules::unused_private_protocol(checker, scope);
}
if checker.enabled(Rule::UnusedPrivateTypeAlias) {
if checker.is_rule_enabled(Rule::UnusedPrivateTypeAlias) {
flake8_pyi::rules::unused_private_type_alias(checker, scope);
}
if checker.enabled(Rule::UnusedPrivateTypedDict) {
if checker.is_rule_enabled(Rule::UnusedPrivateTypedDict) {
flake8_pyi::rules::unused_private_typed_dict(checker, scope);
}
}

if checker.enabled(Rule::AsyncioDanglingTask) {
if checker.is_rule_enabled(Rule::AsyncioDanglingTask) {
ruff::rules::asyncio_dangling_binding(scope, checker);
}

if let Some(class_def) = scope.kind.as_class() {
if checker.enabled(Rule::BuiltinAttributeShadowing) {
if checker.is_rule_enabled(Rule::BuiltinAttributeShadowing) {
flake8_builtins::rules::builtin_attribute_shadowing(
checker, scope_id, scope, class_def,
);
}
if checker.enabled(Rule::FunctionCallInDataclassDefaultArgument) {
if checker.is_rule_enabled(Rule::FunctionCallInDataclassDefaultArgument) {
ruff::rules::function_call_in_dataclass_default(checker, class_def);
}
if checker.enabled(Rule::MutableClassDefault) {
if checker.is_rule_enabled(Rule::MutableClassDefault) {
ruff::rules::mutable_class_default(checker, class_def);
}
if checker.enabled(Rule::MutableDataclassDefault) {
if checker.is_rule_enabled(Rule::MutableDataclassDefault) {
ruff::rules::mutable_dataclass_default(checker, class_def);
}
}

if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Lambda(_)) {
if checker.any_enabled(&[Rule::UnusedVariable, Rule::UnusedUnpackedVariable])
if checker.any_rule_enabled(&[Rule::UnusedVariable, Rule::UnusedUnpackedVariable])
&& !(scope.uses_locals() && scope.kind.is_function())
{
let unused_bindings = scope
Expand Down Expand Up @@ -418,22 +418,22 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
});

for (unused_name, unused_binding) in unused_bindings {
if checker.enabled(Rule::UnusedVariable) {
if checker.is_rule_enabled(Rule::UnusedVariable) {
pyflakes::rules::unused_variable(checker, unused_name, unused_binding);
}

if checker.enabled(Rule::UnusedUnpackedVariable) {
if checker.is_rule_enabled(Rule::UnusedUnpackedVariable) {
ruff::rules::unused_unpacked_variable(checker, unused_name, unused_binding);
}
}
}

if checker.enabled(Rule::UnusedAnnotation) {
if checker.is_rule_enabled(Rule::UnusedAnnotation) {
pyflakes::rules::unused_annotation(checker, scope);
}

if !checker.source_type.is_stub() {
if checker.any_enabled(&[
if checker.any_rule_enabled(&[
Rule::UnusedClassMethodArgument,
Rule::UnusedFunctionArgument,
Rule::UnusedLambdaArgument,
Expand All @@ -447,7 +447,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {

if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Module) {
if !checker.source_type.is_stub()
&& checker.enabled(Rule::RuntimeImportInTypeCheckingBlock)
&& checker.is_rule_enabled(Rule::RuntimeImportInTypeCheckingBlock)
{
flake8_type_checking::rules::runtime_import_in_type_checking_block(checker, scope);
}
Expand All @@ -467,37 +467,37 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
);
}

if checker.enabled(Rule::UnusedImport) {
if checker.is_rule_enabled(Rule::UnusedImport) {
pyflakes::rules::unused_import(checker, scope);
}

if checker.enabled(Rule::ImportPrivateName) {
if checker.is_rule_enabled(Rule::ImportPrivateName) {
pylint::rules::import_private_name(checker, scope);
}
}

if scope.kind.is_function() {
if checker.enabled(Rule::NoSelfUse) {
if checker.is_rule_enabled(Rule::NoSelfUse) {
pylint::rules::no_self_use(checker, scope_id, scope);
}

if checker.enabled(Rule::TooManyLocals) {
if checker.is_rule_enabled(Rule::TooManyLocals) {
pylint::rules::too_many_locals(checker, scope);
}

if checker.enabled(Rule::SingledispatchMethod) {
if checker.is_rule_enabled(Rule::SingledispatchMethod) {
pylint::rules::singledispatch_method(checker, scope);
}

if checker.enabled(Rule::SingledispatchmethodFunction) {
if checker.is_rule_enabled(Rule::SingledispatchmethodFunction) {
pylint::rules::singledispatchmethod_function(checker, scope);
}

if checker.enabled(Rule::BadStaticmethodArgument) {
if checker.is_rule_enabled(Rule::BadStaticmethodArgument) {
pylint::rules::bad_staticmethod_argument(checker, scope);
}

if checker.any_enabled(&[
if checker.any_rule_enabled(&[
Rule::InvalidFirstArgumentNameForClassMethod,
Rule::InvalidFirstArgumentNameForMethod,
]) {
Expand Down
Loading
Loading