mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-09-30 22:01:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Remove redundant settings field from Checker (#18845)

Browse source 
Co-authored-by: Micha Reiser <micha@reiser.io>
This commit is contained in:
Victor Hugo Gomes 2025-06-23 06:06:44 -03:00 • committed by GitHub
parent 0ce022e64e
commit 528ae8083b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
99 changed files with 252 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

4
crates/ruff_linter/src/checkers/ast/analyze/bindings.rs
View file

@ -34,7 +34,7 @@ pub(crate) fn bindings(checker: &Checker) {
if binding.kind.is_bound_exception() if binding.kind.is_bound_exception()
&& binding.is_unused() && binding.is_unused()
&& !checker && !checker
.settings .settings()
.dummy_variable_rgx .dummy_variable_rgx
.is_match(binding.name(checker.source())) .is_match(binding.name(checker.source()))
{ {
@ -67,7 +67,7 @@ pub(crate) fn bindings(checker: &Checker) {
flake8_import_conventions::rules::unconventional_import_alias( flake8_import_conventions::rules::unconventional_import_alias(
checker, checker,
binding, binding,
&checker.settings.flake8_import_conventions.aliases, &checker.settings().flake8_import_conventions.aliases,
); );
} }
if checker.is_rule_enabled(Rule::UnaliasedCollectionsAbcSetImport) { if checker.is_rule_enabled(Rule::UnaliasedCollectionsAbcSetImport) {

8
crates/ruff_linter/src/checkers/ast/analyze/deferred_scopes.rs
View file

@ -76,7 +76,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
flake8_type_checking::helpers::is_valid_runtime_import( flake8_type_checking::helpers::is_valid_runtime_import(
binding, binding,
&checker.semantic, &checker.semantic,
&checker.settings.flake8_type_checking, &checker.settings().flake8_type_checking,
) )
}) })
.collect() .collect()
@ -139,7 +139,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
if !shadowed.kind.is_argument() { if !shadowed.kind.is_argument() {
continue; continue;
} }
if checker.settings.dummy_variable_rgx.is_match(name) { if checker.settings().dummy_variable_rgx.is_match(name) {
continue; continue;
} }
let scope = &checker.semantic.scopes[binding.scope]; let scope = &checker.semantic.scopes[binding.scope];
@ -231,7 +231,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
| BindingKind::FromImport(..) | BindingKind::FromImport(..)
| BindingKind::SubmoduleImport(..) | BindingKind::SubmoduleImport(..)
| BindingKind::FutureImport | BindingKind::FutureImport
) && checker.settings.dummy_variable_rgx.is_match(name) ) && checker.settings().dummy_variable_rgx.is_match(name)
{ {
continue; continue;
} }
@ -402,7 +402,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
&& binding.is_unused() && binding.is_unused()
&& !binding.is_nonlocal() && !binding.is_nonlocal()
&& !binding.is_global() && !binding.is_global()
&& !checker.settings.dummy_variable_rgx.is_match(name) && !checker.settings().dummy_variable_rgx.is_match(name)
&& !matches!( && !matches!(
name, name,
"__tracebackhide__" "__tracebackhide__"

10
crates/ruff_linter/src/checkers/ast/analyze/definitions.rs
View file

@ -167,7 +167,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
if enforce_docstrings || enforce_pydoclint { if enforce_docstrings || enforce_pydoclint {
if pydocstyle::helpers::should_ignore_definition( if pydocstyle::helpers::should_ignore_definition(
definition, definition,
&checker.settings.pydocstyle, &checker.settings().pydocstyle,
&checker.semantic, &checker.semantic,
) { ) {
continue; continue;
@ -253,7 +253,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
pydocstyle::rules::non_imperative_mood( pydocstyle::rules::non_imperative_mood(
checker, checker,
&docstring, &docstring,
&checker.settings.pydocstyle, &checker.settings().pydocstyle,
); );
} }
if checker.is_rule_enabled(Rule::SignatureInDocstring) { if checker.is_rule_enabled(Rule::SignatureInDocstring) {
@ -292,7 +292,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
if enforce_sections || enforce_pydoclint { if enforce_sections || enforce_pydoclint {
let section_contexts = pydocstyle::helpers::get_section_contexts( let section_contexts = pydocstyle::helpers::get_section_contexts(
&docstring, &docstring,
checker.settings.pydocstyle.convention(), checker.settings().pydocstyle.convention(),
); );
if enforce_sections { if enforce_sections {
@ -300,7 +300,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
checker, checker,
&docstring, &docstring,
&section_contexts, &section_contexts,
checker.settings.pydocstyle.convention(), checker.settings().pydocstyle.convention(),
); );
} }
@ -310,7 +310,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
definition, definition,
&docstring, &docstring,
&section_contexts, &section_contexts,
checker.settings.pydocstyle.convention(), checker.settings().pydocstyle.convention(),
); );
} }
} }

4
crates/ruff_linter/src/checkers/ast/analyze/except_handler.rs
View file

@ -41,7 +41,7 @@ pub(crate) fn except_handler(except_handler: &ExceptHandler, checker: &Checker)
except_handler, except_handler,
type_.as_deref(), type_.as_deref(),
body, body,
checker.settings.flake8_bandit.check_typed_exception, checker.settings().flake8_bandit.check_typed_exception,
); );
} }
if checker.is_rule_enabled(Rule::TryExceptContinue) { if checker.is_rule_enabled(Rule::TryExceptContinue) {
@ -50,7 +50,7 @@ pub(crate) fn except_handler(except_handler: &ExceptHandler, checker: &Checker)
except_handler, except_handler,
type_.as_deref(), type_.as_deref(),
body, body,
checker.settings.flake8_bandit.check_typed_exception, checker.settings().flake8_bandit.check_typed_exception,
); );
} }
if checker.is_rule_enabled(Rule::ExceptWithEmptyTuple) { if checker.is_rule_enabled(Rule::ExceptWithEmptyTuple) {

16
crates/ruff_linter/src/checkers/ast/analyze/expression.rs
View file

@ -35,7 +35,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
&& checker.target_version() < PythonVersion::PY310 && checker.target_version() < PythonVersion::PY310
&& checker.target_version() >= PythonVersion::PY37 && checker.target_version() >= PythonVersion::PY37
&& checker.semantic.in_annotation() && checker.semantic.in_annotation()
&& !checker.settings.pyupgrade.keep_runtime_typing && !checker.settings().pyupgrade.keep_runtime_typing
{ {
flake8_future_annotations::rules::future_rewritable_type_annotation( flake8_future_annotations::rules::future_rewritable_type_annotation(
checker, value, checker, value,
@ -51,7 +51,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
|| (checker.target_version() >= PythonVersion::PY37 || (checker.target_version() >= PythonVersion::PY37
&& checker.semantic.future_annotations_or_stub() && checker.semantic.future_annotations_or_stub()
&& checker.semantic.in_annotation() && checker.semantic.in_annotation()
&& !checker.settings.pyupgrade.keep_runtime_typing) && !checker.settings().pyupgrade.keep_runtime_typing)
{ {
pyupgrade::rules::non_pep604_annotation(checker, expr, slice, operator); pyupgrade::rules::non_pep604_annotation(checker, expr, slice, operator);
} }
@ -288,7 +288,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
&& checker.target_version() < PythonVersion::PY39 && checker.target_version() < PythonVersion::PY39
&& checker.target_version() >= PythonVersion::PY37 && checker.target_version() >= PythonVersion::PY37
&& checker.semantic.in_annotation() && checker.semantic.in_annotation()
&& !checker.settings.pyupgrade.keep_runtime_typing && !checker.settings().pyupgrade.keep_runtime_typing
{ {
flake8_future_annotations::rules::future_rewritable_type_annotation(checker, expr); flake8_future_annotations::rules::future_rewritable_type_annotation(checker, expr);
} }
@ -299,7 +299,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
|| (checker.target_version() >= PythonVersion::PY37 || (checker.target_version() >= PythonVersion::PY37
&& checker.semantic.future_annotations_or_stub() && checker.semantic.future_annotations_or_stub()
&& checker.semantic.in_annotation() && checker.semantic.in_annotation()
&& !checker.settings.pyupgrade.keep_runtime_typing) && !checker.settings().pyupgrade.keep_runtime_typing)
{ {
pyupgrade::rules::use_pep585_annotation( pyupgrade::rules::use_pep585_annotation(
checker, checker,
@ -395,7 +395,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
&& checker.target_version() < PythonVersion::PY39 && checker.target_version() < PythonVersion::PY39
&& checker.target_version() >= PythonVersion::PY37 && checker.target_version() >= PythonVersion::PY37
&& checker.semantic.in_annotation() && checker.semantic.in_annotation()
&& !checker.settings.pyupgrade.keep_runtime_typing && !checker.settings().pyupgrade.keep_runtime_typing
{ {
flake8_future_annotations::rules::future_rewritable_type_annotation( flake8_future_annotations::rules::future_rewritable_type_annotation(
checker, expr, checker, expr,
@ -408,7 +408,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
|| (checker.target_version() >= PythonVersion::PY37 || (checker.target_version() >= PythonVersion::PY37
&& checker.semantic.future_annotations_or_stub() && checker.semantic.future_annotations_or_stub()
&& checker.semantic.in_annotation() && checker.semantic.in_annotation()
&& !checker.settings.pyupgrade.keep_runtime_typing) && !checker.settings().pyupgrade.keep_runtime_typing)
{ {
pyupgrade::rules::use_pep585_annotation(checker, expr, &replacement); pyupgrade::rules::use_pep585_annotation(checker, expr, &replacement);
} }
@ -841,7 +841,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
flake8_comprehensions::rules::unnecessary_collection_call( flake8_comprehensions::rules::unnecessary_collection_call(
checker, checker,
call, call,
&checker.settings.flake8_comprehensions, &checker.settings().flake8_comprehensions,
); );
} }
if checker.is_rule_enabled(Rule::UnnecessaryLiteralWithinTupleCall) { if checker.is_rule_enabled(Rule::UnnecessaryLiteralWithinTupleCall) {
@ -1006,7 +1006,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
Rule::PrintfInGetTextFuncCall, Rule::PrintfInGetTextFuncCall,
]) && flake8_gettext::is_gettext_func_call( ]) && flake8_gettext::is_gettext_func_call(
func, func,
&checker.settings.flake8_gettext.functions_names, &checker.settings().flake8_gettext.functions_names,
) { ) {
if checker.is_rule_enabled(Rule::FStringInGetTextFuncCall) { if checker.is_rule_enabled(Rule::FStringInGetTextFuncCall) {
flake8_gettext::rules::f_string_in_gettext_func_call(checker, args); flake8_gettext::rules::f_string_in_gettext_func_call(checker, args);

42
crates/ruff_linter/src/checkers/ast/analyze/statement.rs
View file

@ -132,7 +132,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
stmt, stmt,
name, name,
decorator_list, decorator_list,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
&checker.semantic, &checker.semantic,
); );
} }
@ -189,7 +189,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
checker.semantic.current_scope(), checker.semantic.current_scope(),
stmt, stmt,
name, name,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::GlobalStatement) { if checker.is_rule_enabled(Rule::GlobalStatement) {
@ -240,7 +240,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
stmt, stmt,
name, name,
body, body,
checker.settings.mccabe.max_complexity, checker.settings().mccabe.max_complexity,
); );
} }
if checker.is_rule_enabled(Rule::HardcodedPasswordDefault) { if checker.is_rule_enabled(Rule::HardcodedPasswordDefault) {
@ -265,7 +265,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
checker, checker,
stmt, stmt,
body, body,
checker.settings.pylint.max_returns, checker.settings().pylint.max_returns,
); );
} }
if checker.is_rule_enabled(Rule::TooManyBranches) { if checker.is_rule_enabled(Rule::TooManyBranches) {
@ -273,7 +273,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
checker, checker,
stmt, stmt,
body, body,
checker.settings.pylint.max_branches, checker.settings().pylint.max_branches,
); );
} }
if checker.is_rule_enabled(Rule::TooManyStatements) { if checker.is_rule_enabled(Rule::TooManyStatements) {
@ -281,7 +281,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
checker, checker,
stmt, stmt,
body, body,
checker.settings.pylint.max_statements, checker.settings().pylint.max_statements,
); );
} }
if checker.any_rule_enabled(&[ if checker.any_rule_enabled(&[
@ -431,7 +431,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
pylint::rules::too_many_public_methods( pylint::rules::too_many_public_methods(
checker, checker,
class_def, class_def,
checker.settings.pylint.max_public_methods, checker.settings().pylint.max_public_methods,
); );
} }
if checker.is_rule_enabled(Rule::GlobalStatement) { if checker.is_rule_enabled(Rule::GlobalStatement) {
@ -459,7 +459,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
checker, checker,
stmt, stmt,
name, name,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::ErrorSuffixOnExceptionName) { if checker.is_rule_enabled(Rule::ErrorSuffixOnExceptionName) {
@ -468,7 +468,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
stmt, stmt,
arguments.as_deref(), arguments.as_deref(),
name, name,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if !checker.source_type.is_stub() { if !checker.source_type.is_stub() {
@ -646,7 +646,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::LowercaseImportedAsNonLowercase) { if checker.is_rule_enabled(Rule::LowercaseImportedAsNonLowercase) {
@ -656,7 +656,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::CamelcaseImportedAsLowercase) { if checker.is_rule_enabled(Rule::CamelcaseImportedAsLowercase) {
@ -666,7 +666,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::CamelcaseImportedAsConstant) { if checker.is_rule_enabled(Rule::CamelcaseImportedAsConstant) {
@ -676,7 +676,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::CamelcaseImportedAsAcronym) { if checker.is_rule_enabled(Rule::CamelcaseImportedAsAcronym) {
@ -692,7 +692,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
stmt, stmt,
&alias.name, &alias.name,
asname, asname,
&checker.settings.flake8_import_conventions.banned_aliases, &checker.settings().flake8_import_conventions.banned_aliases,
); );
} }
} }
@ -854,7 +854,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
level, level,
module, module,
checker.module.qualified_name(), checker.module.qualified_name(),
checker.settings.flake8_tidy_imports.ban_relative_imports, checker.settings().flake8_tidy_imports.ban_relative_imports,
); );
} }
if checker.is_rule_enabled(Rule::Debugger) { if checker.is_rule_enabled(Rule::Debugger) {
@ -869,7 +869,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
stmt, stmt,
&qualified_name, &qualified_name,
asname, asname,
&checker.settings.flake8_import_conventions.banned_aliases, &checker.settings().flake8_import_conventions.banned_aliases,
); );
} }
} }
@ -881,7 +881,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::LowercaseImportedAsNonLowercase) { if checker.is_rule_enabled(Rule::LowercaseImportedAsNonLowercase) {
@ -891,7 +891,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::CamelcaseImportedAsLowercase) { if checker.is_rule_enabled(Rule::CamelcaseImportedAsLowercase) {
@ -901,7 +901,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::CamelcaseImportedAsConstant) { if checker.is_rule_enabled(Rule::CamelcaseImportedAsConstant) {
@ -911,7 +911,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
asname, asname,
alias, alias,
stmt, stmt,
&checker.settings.pep8_naming.ignore_names, &checker.settings().pep8_naming.ignore_names,
); );
} }
if checker.is_rule_enabled(Rule::CamelcaseImportedAsAcronym) { if checker.is_rule_enabled(Rule::CamelcaseImportedAsAcronym) {
@ -947,7 +947,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
checker, checker,
stmt, stmt,
&helpers::format_import_from(level, module), &helpers::format_import_from(level, module),
&checker.settings.flake8_import_conventions.banned_from, &checker.settings().flake8_import_conventions.banned_from,
); );
} }
if checker.is_rule_enabled(Rule::ByteStringUsage) { if checker.is_rule_enabled(Rule::ByteStringUsage) {

2
crates/ruff_linter/src/checkers/ast/analyze/string_like.rs
View file

@ -34,7 +34,7 @@ pub(crate) fn string_like(string_like: StringLike, checker: &Checker) {
flake8_quotes::rules::unnecessary_escaped_quote(checker, string_like); flake8_quotes::rules::unnecessary_escaped_quote(checker, string_like);
} }
if checker.is_rule_enabled(Rule::AvoidableEscapedQuote) if checker.is_rule_enabled(Rule::AvoidableEscapedQuote)
&& checker.settings.flake8_quotes.avoid_escape && checker.settings().flake8_quotes.avoid_escape
{ {
flake8_quotes::rules::avoidable_escaped_quote(checker, string_like); flake8_quotes::rules::avoidable_escaped_quote(checker, string_like);
} }

26
crates/ruff_linter/src/checkers/ast/mod.rs
View file

@ -207,8 +207,6 @@ pub(crate) struct Checker<'a> {
/// The [`NoqaMapping`] for the current analysis (i.e., the mapping from line number to /// The [`NoqaMapping`] for the current analysis (i.e., the mapping from line number to
/// suppression commented line number). /// suppression commented line number).
noqa_line_for: &'a NoqaMapping, noqa_line_for: &'a NoqaMapping,
/// The [`LinterSettings`] for the current analysis, including the enabled rules.
pub(crate) settings: &'a LinterSettings,
/// The [`Locator`] for the current file, which enables extraction of source code from byte /// The [`Locator`] for the current file, which enables extraction of source code from byte
/// offsets. /// offsets.
locator: &'a Locator<'a>, locator: &'a Locator<'a>,
@ -260,13 +258,12 @@ impl<'a> Checker<'a> {
notebook_index: Option<&'a NotebookIndex>, notebook_index: Option<&'a NotebookIndex>,
target_version: TargetVersion, target_version: TargetVersion,
context: &'a LintContext<'a>, context: &'a LintContext<'a>,
) -> Checker<'a> { ) -> Self {
let semantic = SemanticModel::new(&settings.typing_modules, path, module); let semantic = SemanticModel::new(&settings.typing_modules, path, module);
Self { Self {
parsed, parsed,
parsed_type_annotation: None, parsed_type_annotation: None,
parsed_annotations_cache: ParsedAnnotationsCache::new(parsed_annotations_arena), parsed_annotations_cache: ParsedAnnotationsCache::new(parsed_annotations_arena),
settings,
noqa_line_for, noqa_line_for,
noqa, noqa,
path, path,
@ -464,6 +461,11 @@ impl<'a> Checker<'a> {
&self.semantic &self.semantic
} }
/// The [`LinterSettings`] for the current analysis, including the enabled rules.
pub(crate) const fn settings(&self) -> &'a LinterSettings {
self.context.settings
}
/// The [`Path`] to the file under analysis. /// The [`Path`] to the file under analysis.
pub(crate) const fn path(&self) -> &'a Path { pub(crate) const fn path(&self) -> &'a Path {
self.path self.path
@ -576,7 +578,7 @@ impl<'a> Checker<'a> {
) -> Option<TypingImporter<'b, 'a>> { ) -> Option<TypingImporter<'b, 'a>> {
let source_module = if self.target_version() >= version_added_to_typing { let source_module = if self.target_version() >= version_added_to_typing {
"typing" "typing"
} else if !self.settings.typing_extensions { } else if !self.settings().typing_extensions {
return None; return None;
} else { } else {
"typing_extensions" "typing_extensions"
@ -1054,7 +1056,7 @@ impl<'a> Visitor<'a> for Checker<'a> {
let annotation = AnnotationContext::from_function( let annotation = AnnotationContext::from_function(
function_def, function_def,
&self.semantic, &self.semantic,
self.settings, self.settings(),
self.target_version(), self.target_version(),
); );
@ -1256,7 +1258,7 @@ impl<'a> Visitor<'a> for Checker<'a> {
}) => { }) => {
match AnnotationContext::from_model( match AnnotationContext::from_model(
&self.semantic, &self.semantic,
self.settings, self.settings(),
self.target_version(), self.target_version(),
) { ) {
AnnotationContext::RuntimeRequired => { AnnotationContext::RuntimeRequired => {
@ -1868,8 +1870,8 @@ impl<'a> Visitor<'a> for Checker<'a> {
match typing::match_annotated_subscript( match typing::match_annotated_subscript(
value, value,
&self.semantic, &self.semantic,
self.settings.typing_modules.iter().map(String::as_str), self.settings().typing_modules.iter().map(String::as_str),
&self.settings.pyflakes.extend_generics, &self.settings().pyflakes.extend_generics,
) { ) {
// Ex) Literal["Class"] // Ex) Literal["Class"]
Some(typing::SubscriptKind::Literal) => { Some(typing::SubscriptKind::Literal) => {
@ -2476,6 +2478,7 @@ impl<'a> Checker<'a> {
fn bind_builtins(&mut self) { fn bind_builtins(&mut self) {
let target_version = self.target_version(); let target_version = self.target_version();
let settings = self.settings();
let mut bind_builtin = |builtin| { let mut bind_builtin = |builtin| {
// Add the builtin to the scope. // Add the builtin to the scope.
let binding_id = self.semantic.push_builtin(); let binding_id = self.semantic.push_builtin();
@ -2489,7 +2492,7 @@ impl<'a> Checker<'a> {
for builtin in MAGIC_GLOBALS { for builtin in MAGIC_GLOBALS {
bind_builtin(builtin); bind_builtin(builtin);
} }
for builtin in &self.settings.builtins { for builtin in &settings.builtins {
bind_builtin(builtin); bind_builtin(builtin);
} }
} }
@ -2963,7 +2966,7 @@ impl<'a> Checker<'a> {
} }
} else { } else {
if self.is_rule_enabled(Rule::UndefinedExport) { if self.is_rule_enabled(Rule::UndefinedExport) {
if is_undefined_export_in_dunder_init_enabled(self.settings) if is_undefined_export_in_dunder_init_enabled(self.settings())
|| !self.path.ends_with("__init__.py") || !self.path.ends_with("__init__.py")
{ {
self.report_diagnostic( self.report_diagnostic(
@ -3115,7 +3118,6 @@ pub(crate) struct LintContext<'a> {
diagnostics: RefCell<Vec<OldDiagnostic>>, diagnostics: RefCell<Vec<OldDiagnostic>>,
source_file: SourceFile, source_file: SourceFile,
rules: RuleTable, rules: RuleTable,
#[expect(unused, reason = "TODO(brent) use this instead of Checker::settings")]
settings: &'a LinterSettings, settings: &'a LinterSettings,
} }

26
crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs
View file

@ -648,9 +648,9 @@ pub(crate) fn definition(
); );
} }
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings().flake8_annotations.suppress_dummy_args
&& checker && checker
.settings .settings()
.dummy_variable_rgx .dummy_variable_rgx
.is_match(parameter.name())) .is_match(parameter.name()))
{ {
@ -670,15 +670,15 @@ pub(crate) fn definition(
if let Some(arg) = &parameters.vararg { if let Some(arg) = &parameters.vararg {
if let Some(expr) = &arg.annotation { if let Some(expr) = &arg.annotation {
has_any_typed_arg = true; has_any_typed_arg = true;
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings().flake8_annotations.allow_star_arg_any {
if checker.is_rule_enabled(Rule::AnyType) && !is_overridden { if checker.is_rule_enabled(Rule::AnyType) && !is_overridden {
let name = &arg.name; let name = &arg.name;
check_dynamically_typed(checker, expr, || format!("*{name}"), &mut diagnostics); check_dynamically_typed(checker, expr, || format!("*{name}"), &mut diagnostics);
} }
} }
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings().flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.name)) && checker.settings().dummy_variable_rgx.is_match(&arg.name))
{ {
if checker.is_rule_enabled(Rule::MissingTypeArgs) { if checker.is_rule_enabled(Rule::MissingTypeArgs) {
diagnostics.push(checker.report_diagnostic( diagnostics.push(checker.report_diagnostic(
@ -696,7 +696,7 @@ pub(crate) fn definition(
if let Some(arg) = &parameters.kwarg { if let Some(arg) = &parameters.kwarg {
if let Some(expr) = &arg.annotation { if let Some(expr) = &arg.annotation {
has_any_typed_arg = true; has_any_typed_arg = true;
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings().flake8_annotations.allow_star_arg_any {
if checker.is_rule_enabled(Rule::AnyType) && !is_overridden { if checker.is_rule_enabled(Rule::AnyType) && !is_overridden {
let name = &arg.name; let name = &arg.name;
check_dynamically_typed( check_dynamically_typed(
@ -708,8 +708,8 @@ pub(crate) fn definition(
} }
} }
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings().flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.name)) && checker.settings().dummy_variable_rgx.is_match(&arg.name))
{ {
if checker.is_rule_enabled(Rule::MissingTypeKwargs) { if checker.is_rule_enabled(Rule::MissingTypeKwargs) {
diagnostics.push(checker.report_diagnostic( diagnostics.push(checker.report_diagnostic(
@ -732,7 +732,11 @@ pub(crate) fn definition(
} else if !( } else if !(
// Allow omission of return annotation if the function only returns `None` // Allow omission of return annotation if the function only returns `None`
// (explicitly or implicitly). // (explicitly or implicitly).
checker.settings.flake8_annotations.suppress_none_returning && is_none_returning(body) checker
.settings()
.flake8_annotations
.suppress_none_returning
&& is_none_returning(body)
) { ) {
if is_method && visibility::is_classmethod(decorator_list, checker.semantic()) { if is_method && visibility::is_classmethod(decorator_list, checker.semantic()) {
if checker.is_rule_enabled(Rule::MissingReturnTypeClassMethod) { if checker.is_rule_enabled(Rule::MissingReturnTypeClassMethod) {
@ -790,7 +794,7 @@ pub(crate) fn definition(
// Allow omission of return annotation in `__init__` functions, as long as at // Allow omission of return annotation in `__init__` functions, as long as at
// least one argument is typed. // least one argument is typed.
if checker.is_rule_enabled(Rule::MissingReturnTypeSpecialMethod) { if checker.is_rule_enabled(Rule::MissingReturnTypeSpecialMethod) {
if !(checker.settings.flake8_annotations.mypy_init_return && has_any_typed_arg) { if !(checker.settings().flake8_annotations.mypy_init_return && has_any_typed_arg) {
let mut diagnostic = checker.report_diagnostic( let mut diagnostic = checker.report_diagnostic(
MissingReturnTypeSpecialMethod { MissingReturnTypeSpecialMethod {
name: name.to_string(), name: name.to_string(),
@ -901,7 +905,7 @@ pub(crate) fn definition(
// If settings say so, don't report any of the // If settings say so, don't report any of the
// diagnostics gathered here if there were no type annotations at all. // diagnostics gathered here if there were no type annotations at all.
let diagnostics_enabled = !checker.settings.flake8_annotations.ignore_fully_untyped let diagnostics_enabled = !checker.settings().flake8_annotations.ignore_fully_untyped
|| has_any_typed_arg || has_any_typed_arg
|| has_typed_return || has_typed_return
|| (is_method || (is_method

2
crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_tmp_directory.rs
View file

@ -84,7 +84,7 @@ pub(crate) fn hardcoded_tmp_directory(checker: &Checker, string: StringLike) {
fn check(checker: &Checker, value: &str, range: TextRange) { fn check(checker: &Checker, value: &str, range: TextRange) {
if !checker if !checker
.settings .settings()
.flake8_bandit .flake8_bandit
.hardcoded_tmp_directory .hardcoded_tmp_directory
.iter() .iter()

4
crates/ruff_linter/src/rules/flake8_bandit/rules/suspicious_function_call.rs
View file

@ -936,7 +936,7 @@ pub(crate) fn suspicious_function_call(checker: &Checker, call: &ExprCall) {
} }
pub(crate) fn suspicious_function_reference(checker: &Checker, func: &Expr) { pub(crate) fn suspicious_function_reference(checker: &Checker, func: &Expr) {
if !is_suspicious_function_reference_enabled(checker.settings) { if !is_suspicious_function_reference_enabled(checker.settings()) {
return; return;
} }
@ -1270,7 +1270,7 @@ fn suspicious_function(
/// S308 /// S308
pub(crate) fn suspicious_function_decorator(checker: &Checker, decorator: &Decorator) { pub(crate) fn suspicious_function_decorator(checker: &Checker, decorator: &Decorator) {
// In preview mode, references are handled collectively by `suspicious_function_reference` // In preview mode, references are handled collectively by `suspicious_function_reference`
if !is_suspicious_function_reference_enabled(checker.settings) { if !is_suspicious_function_reference_enabled(checker.settings()) {
suspicious_function(checker, &decorator.expression, None, decorator.range); suspicious_function(checker, &decorator.expression, None, decorator.range);
} }
} }

6
crates/ruff_linter/src/rules/flake8_bandit/rules/unsafe_markup_use.rs
View file

@ -90,7 +90,7 @@ impl Violation for UnsafeMarkupUse {
/// S704 /// S704
pub(crate) fn unsafe_markup_call(checker: &Checker, call: &ExprCall) { pub(crate) fn unsafe_markup_call(checker: &Checker, call: &ExprCall) {
if checker if checker
.settings .settings()
.flake8_bandit .flake8_bandit
.extend_markup_names .extend_markup_names
.is_empty() .is_empty()
@ -100,7 +100,7 @@ pub(crate) fn unsafe_markup_call(checker: &Checker, call: &ExprCall) {
return; return;
} }
if !is_unsafe_call(call, checker.semantic(), checker.settings) { if !is_unsafe_call(call, checker.semantic(), checker.settings()) {
return; return;
} }
@ -108,7 +108,7 @@ pub(crate) fn unsafe_markup_call(checker: &Checker, call: &ExprCall) {
return; return;
}; };
if !is_markup_call(&qualified_name, checker.settings) { if !is_markup_call(&qualified_name, checker.settings()) {
return; return;
} }

2
crates/ruff_linter/src/rules/flake8_blind_except/rules/blind_except.rs
View file

@ -101,7 +101,7 @@ pub(crate) fn blind_except(
} }
// If the exception is logged, don't flag an error. // If the exception is logged, don't flag an error.
let mut visitor = LogExceptionVisitor::new(semantic, &checker.settings.logger_objects); let mut visitor = LogExceptionVisitor::new(semantic, &checker.settings().logger_objects);
visitor.visit_body(body); visitor.visit_body(body);
if visitor.seen() { if visitor.seen() {
return; return;

2
crates/ruff_linter/src/rules/flake8_boolean_trap/helpers.rs
View file

@ -185,7 +185,7 @@ pub(super) fn allow_boolean_trap(call: &ast::ExprCall, checker: &Checker) -> boo
} }
// If the call is explicitly allowed by the user, then the boolean trap is allowed. // If the call is explicitly allowed by the user, then the boolean trap is allowed.
if is_user_allowed_func_call(call, checker.semantic(), checker.settings) { if is_user_allowed_func_call(call, checker.semantic(), checker.settings()) {
return true; return true;
} }

4
crates/ruff_linter/src/rules/flake8_bugbear/rules/cached_instance_method.rs
View file

@ -88,8 +88,8 @@ pub(crate) fn cached_instance_method(checker: &Checker, function_def: &ast::Stmt
&function_def.decorator_list, &function_def.decorator_list,
scope, scope,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
if !matches!(type_, function_type::FunctionType::Method) { if !matches!(type_, function_type::FunctionType::Method) {
return; return;

2
crates/ruff_linter/src/rules/flake8_bugbear/rules/function_call_in_argument_default.rs
View file

@ -132,7 +132,7 @@ impl Visitor<'_> for ArgumentDefaultVisitor<'_, '_> {
pub(crate) fn function_call_in_argument_default(checker: &Checker, parameters: &Parameters) { pub(crate) fn function_call_in_argument_default(checker: &Checker, parameters: &Parameters) {
// Map immutable calls to (module, member) format. // Map immutable calls to (module, member) format.
let extend_immutable_calls: Vec<QualifiedName> = checker let extend_immutable_calls: Vec<QualifiedName> = checker
.settings .settings()
.flake8_bugbear .flake8_bugbear
.extend_immutable_calls .extend_immutable_calls
.iter() .iter()

2
crates/ruff_linter/src/rules/flake8_bugbear/rules/mutable_argument_default.rs
View file

@ -105,7 +105,7 @@ pub(crate) fn mutable_argument_default(checker: &Checker, function_def: &ast::St
}; };
let extend_immutable_calls: Vec<QualifiedName> = checker let extend_immutable_calls: Vec<QualifiedName> = checker
.settings .settings()
.flake8_bugbear .flake8_bugbear
.extend_immutable_calls .extend_immutable_calls
.iter() .iter()

2
crates/ruff_linter/src/rules/flake8_bugbear/rules/mutable_contextvar_default.rs
View file

@ -82,7 +82,7 @@ pub(crate) fn mutable_contextvar_default(checker: &Checker, call: &ast::ExprCall
}; };
let extend_immutable_calls: Vec<QualifiedName> = checker let extend_immutable_calls: Vec<QualifiedName> = checker
.settings .settings()
.flake8_bugbear .flake8_bugbear
.extend_immutable_calls .extend_immutable_calls
.iter() .iter()

4
crates/ruff_linter/src/rules/flake8_bugbear/rules/unused_loop_control_variable.rs
View file

@ -93,7 +93,7 @@ pub(crate) fn unused_loop_control_variable(checker: &Checker, stmt_for: &ast::St
for (name, expr) in control_names { for (name, expr) in control_names {
// Ignore names that are already underscore-prefixed. // Ignore names that are already underscore-prefixed.
if checker.settings.dummy_variable_rgx.is_match(name) { if checker.settings().dummy_variable_rgx.is_match(name) {
continue; continue;
} }
@ -116,7 +116,7 @@ pub(crate) fn unused_loop_control_variable(checker: &Checker, stmt_for: &ast::St
// violation in the next pass. // violation in the next pass.
let rename = format!("_{name}"); let rename = format!("_{name}");
let rename = checker let rename = checker
.settings .settings()
.dummy_variable_rgx .dummy_variable_rgx
.is_match(rename.as_str()) .is_match(rename.as_str())
.then_some(rename); .then_some(rename);

2
crates/ruff_linter/src/rules/flake8_builtins/rules/builtin_argument_shadowing.rs
View file

@ -66,7 +66,7 @@ pub(crate) fn builtin_argument_shadowing(checker: &Checker, parameter: &Paramete
if shadows_builtin( if shadows_builtin(
parameter.name(), parameter.name(),
checker.source_type, checker.source_type,
&checker.settings.flake8_builtins.ignorelist, &checker.settings().flake8_builtins.ignorelist,
checker.target_version(), checker.target_version(),
) { ) {
// Ignore parameters in lambda expressions. // Ignore parameters in lambda expressions.

2
crates/ruff_linter/src/rules/flake8_builtins/rules/builtin_attribute_shadowing.rs
View file

@ -97,7 +97,7 @@ pub(crate) fn builtin_attribute_shadowing(
if shadows_builtin( if shadows_builtin(
name, name,
checker.source_type, checker.source_type,
&checker.settings.flake8_builtins.ignorelist, &checker.settings().flake8_builtins.ignorelist,
checker.target_version(), checker.target_version(),
) { ) {
// Ignore explicit overrides. // Ignore explicit overrides.

2
crates/ruff_linter/src/rules/flake8_builtins/rules/builtin_import_shadowing.rs
View file

@ -59,7 +59,7 @@ pub(crate) fn builtin_import_shadowing(checker: &Checker, alias: &Alias) {
if shadows_builtin( if shadows_builtin(
name.as_str(), name.as_str(),
checker.source_type, checker.source_type,
&checker.settings.flake8_builtins.ignorelist, &checker.settings().flake8_builtins.ignorelist,
checker.target_version(), checker.target_version(),
) { ) {
checker.report_diagnostic( checker.report_diagnostic(

2
crates/ruff_linter/src/rules/flake8_builtins/rules/builtin_lambda_argument_shadowing.rs
View file

@ -43,7 +43,7 @@ pub(crate) fn builtin_lambda_argument_shadowing(checker: &Checker, lambda: &Expr
if shadows_builtin( if shadows_builtin(
name, name,
checker.source_type, checker.source_type,
&checker.settings.flake8_builtins.ignorelist, &checker.settings().flake8_builtins.ignorelist,
checker.target_version(), checker.target_version(),
) { ) {
checker.report_diagnostic( checker.report_diagnostic(

2
crates/ruff_linter/src/rules/flake8_builtins/rules/builtin_variable_shadowing.rs
View file

@ -70,7 +70,7 @@ pub(crate) fn builtin_variable_shadowing(checker: &Checker, name: &str, range: T
if shadows_builtin( if shadows_builtin(
name, name,
checker.source_type, checker.source_type,
&checker.settings.flake8_builtins.ignorelist, &checker.settings().flake8_builtins.ignorelist,
checker.target_version(), checker.target_version(),
) { ) {
checker.report_diagnostic( checker.report_diagnostic(

2
crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_comprehension_in_call.rs
View file

@ -126,7 +126,7 @@ pub(crate) fn unnecessary_comprehension_in_call(
if !(matches!( if !(matches!(
builtin_function, builtin_function,
SupportedBuiltins::Any | SupportedBuiltins::All SupportedBuiltins::Any | SupportedBuiltins::All
) || (is_comprehension_with_min_max_sum_enabled(checker.settings) ) || (is_comprehension_with_min_max_sum_enabled(checker.settings())
&& matches!( && matches!(
builtin_function, builtin_function,
SupportedBuiltins::Sum | SupportedBuiltins::Min | SupportedBuiltins::Max SupportedBuiltins::Sum | SupportedBuiltins::Min | SupportedBuiltins::Max

2
crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_literal_within_tuple_call.rs
View file

@ -101,7 +101,7 @@ pub(crate) fn unnecessary_literal_within_tuple_call(
let argument_kind = match argument { let argument_kind = match argument {
Expr::Tuple(_) => TupleLiteralKind::Tuple, Expr::Tuple(_) => TupleLiteralKind::Tuple,
Expr::List(_) => TupleLiteralKind::List, Expr::List(_) => TupleLiteralKind::List,
Expr::ListComp(_) if is_check_comprehensions_in_tuple_call_enabled(checker.settings) => { Expr::ListComp(_) if is_check_comprehensions_in_tuple_call_enabled(checker.settings()) => {
TupleLiteralKind::ListComp TupleLiteralKind::ListComp
} }
_ => return, _ => return,

2
crates/ruff_linter/src/rules/flake8_errmsg/rules/string_in_exception.rs
View file

@ -186,7 +186,7 @@ pub(crate) fn string_in_exception(checker: &Checker, stmt: &Stmt, exc: &Expr) {
// Check for string literals. // Check for string literals.
Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) => { Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) => {
if checker.is_rule_enabled(Rule::RawStringInException) { if checker.is_rule_enabled(Rule::RawStringInException) {
if string.len() >= checker.settings.flake8_errmsg.max_string_length { if string.len() >= checker.settings().flake8_errmsg.max_string_length {
let mut diagnostic = let mut diagnostic =
checker.report_diagnostic(RawStringInException, first.range()); checker.report_diagnostic(RawStringInException, first.range());
if let Some(indentation) = if let Some(indentation) =

6
crates/ruff_linter/src/rules/flake8_implicit_str_concat/rules/explicit.rs
View file

@ -52,7 +52,11 @@ pub(crate) fn explicit(checker: &Checker, expr: &Expr) {
// strings that span multiple lines even if this rule is enabled. Otherwise, there's no way // strings that span multiple lines even if this rule is enabled. Otherwise, there's no way
// for the user to write multiline strings, and that setting is "more explicit" than this rule // for the user to write multiline strings, and that setting is "more explicit" than this rule
// being enabled. // being enabled.
if !checker.settings.flake8_implicit_str_concat.allow_multiline { if !checker
.settings()
.flake8_implicit_str_concat
.allow_multiline
{
return; return;
} }

2
crates/ruff_linter/src/rules/flake8_logging/rules/exc_info_outside_except_handler.rs
View file

@ -68,7 +68,7 @@ pub(crate) fn exc_info_outside_except_handler(checker: &Checker, call: &ExprCall
match &*call.func { match &*call.func {
func @ Expr::Attribute(ExprAttribute { attr, .. }) => { func @ Expr::Attribute(ExprAttribute { attr, .. }) => {
if !is_logger_candidate(func, semantic, &checker.settings.logger_objects) { if !is_logger_candidate(func, semantic, &checker.settings().logger_objects) {
return; return;
} }

2
crates/ruff_linter/src/rules/flake8_logging/rules/exception_without_exc_info.rs
View file

@ -54,7 +54,7 @@ pub(crate) fn exception_without_exc_info(checker: &Checker, call: &ExprCall) {
if !logging::is_logger_candidate( if !logging::is_logger_candidate(
&call.func, &call.func,
checker.semantic(), checker.semantic(),
&checker.settings.logger_objects, &checker.settings().logger_objects,
) { ) {
return; return;
} }

2
crates/ruff_linter/src/rules/flake8_logging/rules/log_exception_outside_except_handler.rs
View file

@ -69,7 +69,7 @@ pub(crate) fn log_exception_outside_except_handler(checker: &Checker, call: &Exp
let fix = match &*call.func { let fix = match &*call.func {
func @ Expr::Attribute(ExprAttribute { attr, .. }) => { func @ Expr::Attribute(ExprAttribute { attr, .. }) => {
let logger_objects = &checker.settings.logger_objects; let logger_objects = &checker.settings().logger_objects;
if !logging::is_logger_candidate(func, semantic, logger_objects) { if !logging::is_logger_candidate(func, semantic, logger_objects) {
return; return;

2
crates/ruff_linter/src/rules/flake8_logging_format/rules/logging_call.rs
View file

@ -147,7 +147,7 @@ pub(crate) fn logging_call(checker: &Checker, call: &ast::ExprCall) {
if !logging::is_logger_candidate( if !logging::is_logger_candidate(
&call.func, &call.func,
checker.semantic(), checker.semantic(),
&checker.settings.logger_objects, &checker.settings().logger_objects,
) { ) {
return; return;
} }

2
crates/ruff_linter/src/rules/flake8_pyi/rules/bad_version_info_comparison.rs
View file

@ -141,7 +141,7 @@ pub(crate) fn bad_version_info_comparison(checker: &Checker, test: &Expr, has_el
if matches!(op, CmpOp::Lt) { if matches!(op, CmpOp::Lt) {
if checker.is_rule_enabled(Rule::BadVersionInfoOrder) if checker.is_rule_enabled(Rule::BadVersionInfoOrder)
// See https://github.com/astral-sh/ruff/issues/15347 // See https://github.com/astral-sh/ruff/issues/15347
&& (checker.source_type.is_stub() || is_bad_version_info_in_non_stub_enabled(checker.settings)) && (checker.source_type.is_stub() || is_bad_version_info_in_non_stub_enabled(checker.settings()))
{ {
if has_else_clause { if has_else_clause {
checker.report_diagnostic(BadVersionInfoOrder, test.range()); checker.report_diagnostic(BadVersionInfoOrder, test.range());

4
crates/ruff_linter/src/rules/flake8_pyi/rules/custom_type_var_for_self.rs
View file

@ -173,8 +173,8 @@ pub(crate) fn custom_type_var_instead_of_self(checker: &Checker, binding: &Bindi
decorator_list, decorator_list,
current_scope, current_scope,
semantic, semantic,
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
let method = match function_kind { let method = match function_kind {

4
crates/ruff_linter/src/rules/flake8_pyi/rules/pre_pep570_positional_argument.rs
View file

@ -75,8 +75,8 @@ pub(crate) fn pep_484_positional_parameter(checker: &Checker, function_def: &ast
&function_def.decorator_list, &function_def.decorator_list,
scope, scope,
semantic, semantic,
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
// If the method has a `self` or `cls` argument, skip it. // If the method has a `self` or `cls` argument, skip it.

4
crates/ruff_linter/src/rules/flake8_pytest_style/rules/fixture.rs
View file

@ -714,7 +714,7 @@ fn check_fixture_decorator(checker: &Checker, func_name: &str, decorator: &Decor
node_index: _, node_index: _,
}) => { }) => {
if checker.is_rule_enabled(Rule::PytestFixtureIncorrectParenthesesStyle) { if checker.is_rule_enabled(Rule::PytestFixtureIncorrectParenthesesStyle) {
if !checker.settings.flake8_pytest_style.fixture_parentheses if !checker.settings().flake8_pytest_style.fixture_parentheses
&& arguments.args.is_empty() && arguments.args.is_empty()
&& arguments.keywords.is_empty() && arguments.keywords.is_empty()
{ {
@ -771,7 +771,7 @@ fn check_fixture_decorator(checker: &Checker, func_name: &str, decorator: &Decor
} }
_ => { _ => {
if checker.is_rule_enabled(Rule::PytestFixtureIncorrectParenthesesStyle) { if checker.is_rule_enabled(Rule::PytestFixtureIncorrectParenthesesStyle) {
if checker.settings.flake8_pytest_style.fixture_parentheses { if checker.settings().flake8_pytest_style.fixture_parentheses {
let fix = Fix::safe_edit(Edit::insertion( let fix = Fix::safe_edit(Edit::insertion(
Parentheses::Empty.to_string(), Parentheses::Empty.to_string(),
decorator.end(), decorator.end(),

4
crates/ruff_linter/src/rules/flake8_pytest_style/rules/marks.rs
View file

@ -165,7 +165,7 @@ fn check_mark_parentheses(checker: &Checker, decorator: &Decorator, marker: &str
range: _, range: _,
node_index: _, node_index: _,
}) => { }) => {
if !checker.settings.flake8_pytest_style.mark_parentheses if !checker.settings().flake8_pytest_style.mark_parentheses
&& args.is_empty() && args.is_empty()
&& keywords.is_empty() && keywords.is_empty()
{ {
@ -191,7 +191,7 @@ fn check_mark_parentheses(checker: &Checker, decorator: &Decorator, marker: &str
} }
} }
_ => { _ => {
if checker.settings.flake8_pytest_style.mark_parentheses { if checker.settings().flake8_pytest_style.mark_parentheses {
let fix = Fix::safe_edit(Edit::insertion( let fix = Fix::safe_edit(Edit::insertion(
Parentheses::Empty.to_string(), Parentheses::Empty.to_string(),
decorator.end(), decorator.end(),

12
crates/ruff_linter/src/rules/flake8_pytest_style/rules/parametrize.rs
View file

@ -335,7 +335,10 @@ fn get_parametrize_name_range(
/// PT006 /// PT006
fn check_names(checker: &Checker, call: &ExprCall, expr: &Expr, argvalues: &Expr) { fn check_names(checker: &Checker, call: &ExprCall, expr: &Expr, argvalues: &Expr) {
let names_type = checker.settings.flake8_pytest_style.parametrize_names_type; let names_type = checker
.settings()
.flake8_pytest_style
.parametrize_names_type;
match expr { match expr {
Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => { Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
@ -516,10 +519,13 @@ fn check_names(checker: &Checker, call: &ExprCall, expr: &Expr, argvalues: &Expr
/// PT007 /// PT007
fn check_values(checker: &Checker, names: &Expr, values: &Expr) { fn check_values(checker: &Checker, names: &Expr, values: &Expr) {
let values_type = checker.settings.flake8_pytest_style.parametrize_values_type; let values_type = checker
.settings()
.flake8_pytest_style
.parametrize_values_type;
let values_row_type = checker let values_row_type = checker
.settings .settings()
.flake8_pytest_style .flake8_pytest_style
.parametrize_values_row_type; .parametrize_values_row_type;

4
crates/ruff_linter/src/rules/flake8_pytest_style/rules/raises.rs
View file

@ -244,13 +244,13 @@ fn exception_needs_match(checker: &Checker, exception: &Expr) {
.and_then(|qualified_name| { .and_then(|qualified_name| {
let qualified_name = qualified_name.to_string(); let qualified_name = qualified_name.to_string();
checker checker
.settings .settings()
.flake8_pytest_style .flake8_pytest_style
.raises_require_match_for .raises_require_match_for
.iter() .iter()
.chain( .chain(
&checker &checker
.settings .settings()
.flake8_pytest_style .flake8_pytest_style
.raises_extend_require_match_for, .raises_extend_require_match_for,
) )

4
crates/ruff_linter/src/rules/flake8_pytest_style/rules/warns.rs
View file

@ -233,13 +233,13 @@ fn warning_needs_match(checker: &Checker, warning: &Expr) {
.and_then(|qualified_name| { .and_then(|qualified_name| {
let qualified_name = qualified_name.to_string(); let qualified_name = qualified_name.to_string();
checker checker
.settings .settings()
.flake8_pytest_style .flake8_pytest_style
.warns_require_match_for .warns_require_match_for
.iter() .iter()
.chain( .chain(
&checker &checker
.settings .settings()
.flake8_pytest_style .flake8_pytest_style
.warns_extend_require_match_for, .warns_extend_require_match_for,
) )

2
crates/ruff_linter/src/rules/flake8_quotes/rules/avoidable_escaped_quote.rs
View file

@ -86,7 +86,7 @@ impl<'a, 'b> AvoidableEscapedQuoteChecker<'a, 'b> {
fn new(checker: &'a Checker<'b>, target_version: PythonVersion) -> Self { fn new(checker: &'a Checker<'b>, target_version: PythonVersion) -> Self {
Self { Self {
checker, checker,
quotes_settings: &checker.settings.flake8_quotes, quotes_settings: &checker.settings().flake8_quotes,
supports_pep701: target_version.supports_pep_701(), supports_pep701: target_version.supports_pep_701(),
} }
} }

4
crates/ruff_linter/src/rules/flake8_quotes/rules/check_string_quotes.rs
View file

@ -251,7 +251,7 @@ fn text_ends_at_quote(locator: &Locator, range: TextRange, quote: Quote) -> bool
/// Q002 /// Q002
fn docstring(checker: &Checker, range: TextRange) { fn docstring(checker: &Checker, range: TextRange) {
let quotes_settings = &checker.settings.flake8_quotes; let quotes_settings = &checker.settings().flake8_quotes;
let locator = checker.locator(); let locator = checker.locator();
let text = locator.slice(range); let text = locator.slice(range);
@ -302,7 +302,7 @@ fn docstring(checker: &Checker, range: TextRange) {
/// Q000, Q001 /// Q000, Q001
fn strings(checker: &Checker, sequence: &[TextRange]) { fn strings(checker: &Checker, sequence: &[TextRange]) {
let quotes_settings = &checker.settings.flake8_quotes; let quotes_settings = &checker.settings().flake8_quotes;
let locator = checker.locator(); let locator = checker.locator();
let trivia = sequence let trivia = sequence

2
crates/ruff_linter/src/rules/flake8_return/rules/function.rs
View file

@ -379,7 +379,7 @@ fn unnecessary_return_none(checker: &Checker, decorator_list: &[Decorator], stac
// Skip property functions // Skip property functions
if is_property( if is_property(
decorator_list, decorator_list,
checker.settings.pydocstyle.property_decorators(), checker.settings().pydocstyle.property_decorators(),
checker.semantic(), checker.semantic(),
) { ) {
return; return;

2
crates/ruff_linter/src/rules/flake8_self/rules/private_member_access.rs
View file

@ -85,7 +85,7 @@ pub(crate) fn private_member_access(checker: &Checker, expr: &Expr) {
} }
if checker if checker
.settings .settings()
.flake8_self .flake8_self
.ignore_names .ignore_names
.contains(attr.id()) .contains(attr.id())

6
crates/ruff_linter/src/rules/flake8_simplify/rules/ast_with.rs
View file

@ -191,11 +191,11 @@ pub(crate) fn multiple_with_statements(
content, content,
with_stmt.into(), with_stmt.into(),
checker.locator(), checker.locator(),
checker.settings.pycodestyle.max_line_length, checker.settings().pycodestyle.max_line_length,
checker.settings.tab_size, checker.settings().tab_size,
) )
}) { }) {
if is_multiple_with_statements_fix_safe_enabled(checker.settings) { if is_multiple_with_statements_fix_safe_enabled(checker.settings()) {
Ok(Some(Fix::safe_edit(edit))) Ok(Some(Fix::safe_edit(edit)))
} else { } else {
Ok(Some(Fix::unsafe_edit(edit))) Ok(Some(Fix::unsafe_edit(edit)))

4
crates/ruff_linter/src/rules/flake8_simplify/rules/collapsible_if.rs
View file

@ -125,8 +125,8 @@ pub(crate) fn nested_if_statements(
content, content,
(&nested_if).into(), (&nested_if).into(),
checker.locator(), checker.locator(),
checker.settings.pycodestyle.max_line_length, checker.settings().pycodestyle.max_line_length,
checker.settings.tab_size, checker.settings().tab_size,
) )
}) { }) {
Ok(Some(Fix::unsafe_edit(edit))) Ok(Some(Fix::unsafe_edit(edit)))

4
crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_dict_get.rs
View file

@ -215,8 +215,8 @@ pub(crate) fn if_else_block_instead_of_dict_get(checker: &Checker, stmt_if: &ast
&contents, &contents,
stmt_if.into(), stmt_if.into(),
checker.locator(), checker.locator(),
checker.settings.pycodestyle.max_line_length, checker.settings().pycodestyle.max_line_length,
checker.settings.tab_size, checker.settings().tab_size,
) { ) {
return; return;
} }

4
crates/ruff_linter/src/rules/flake8_simplify/rules/if_else_block_instead_of_if_exp.rs
View file

@ -225,8 +225,8 @@ pub(crate) fn if_else_block_instead_of_if_exp(checker: &Checker, stmt_if: &ast::
&contents, &contents,
stmt_if.into(), stmt_if.into(),
checker.locator(), checker.locator(),
checker.settings.pycodestyle.max_line_length, checker.settings().pycodestyle.max_line_length,
checker.settings.tab_size, checker.settings().tab_size,
) { ) {
return; return;
} }

8
crates/ruff_linter/src/rules/flake8_simplify/rules/reimplemented_builtin.rs
View file

@ -105,8 +105,8 @@ pub(crate) fn convert_for_loop_to_any_all(checker: &Checker, stmt: &Stmt) {
&contents, &contents,
stmt.into(), stmt.into(),
checker.locator(), checker.locator(),
checker.settings.pycodestyle.max_line_length, checker.settings().pycodestyle.max_line_length,
checker.settings.tab_size, checker.settings().tab_size,
) { ) {
return; return;
} }
@ -195,14 +195,14 @@ pub(crate) fn convert_for_loop_to_any_all(checker: &Checker, stmt: &Stmt) {
// Don't flag if the resulting expression would exceed the maximum line length. // Don't flag if the resulting expression would exceed the maximum line length.
let line_start = checker.locator().line_start(stmt.start()); let line_start = checker.locator().line_start(stmt.start());
if LineWidthBuilder::new(checker.settings.tab_size) if LineWidthBuilder::new(checker.settings().tab_size)
.add_str( .add_str(
checker checker
.locator() .locator()
.slice(TextRange::new(line_start, stmt.start())), .slice(TextRange::new(line_start, stmt.start())),
) )
.add_str(&contents) .add_str(&contents)
> checker.settings.pycodestyle.max_line_length > checker.settings().pycodestyle.max_line_length
{ {
return; return;
} }

4
crates/ruff_linter/src/rules/flake8_tidy_imports/rules/banned_api.rs
View file

@ -40,7 +40,7 @@ impl Violation for BannedApi {
/// TID251 /// TID251
pub(crate) fn banned_api<T: Ranged>(checker: &Checker, policy: &NameMatchPolicy, node: &T) { pub(crate) fn banned_api<T: Ranged>(checker: &Checker, policy: &NameMatchPolicy, node: &T) {
let banned_api = &checker.settings.flake8_tidy_imports.banned_api; let banned_api = &checker.settings().flake8_tidy_imports.banned_api;
if let Some(banned_module) = policy.find(banned_api.keys().map(AsRef::as_ref)) { if let Some(banned_module) = policy.find(banned_api.keys().map(AsRef::as_ref)) {
if let Some(reason) = banned_api.get(&banned_module) { if let Some(reason) = banned_api.get(&banned_module) {
checker.report_diagnostic( checker.report_diagnostic(
@ -56,7 +56,7 @@ pub(crate) fn banned_api<T: Ranged>(checker: &Checker, policy: &NameMatchPolicy,
/// TID251 /// TID251
pub(crate) fn banned_attribute_access(checker: &Checker, expr: &Expr) { pub(crate) fn banned_attribute_access(checker: &Checker, expr: &Expr) {
let banned_api = &checker.settings.flake8_tidy_imports.banned_api; let banned_api = &checker.settings().flake8_tidy_imports.banned_api;
if banned_api.is_empty() { if banned_api.is_empty() {
return; return;
} }

2
crates/ruff_linter/src/rules/flake8_tidy_imports/rules/banned_module_level_imports.rs
View file

@ -64,7 +64,7 @@ pub(crate) fn banned_module_level_imports(checker: &Checker, stmt: &Stmt) {
for (policy, node) in &BannedModuleImportPolicies::new(stmt, checker) { for (policy, node) in &BannedModuleImportPolicies::new(stmt, checker) {
if let Some(banned_module) = policy.find( if let Some(banned_module) = policy.find(
checker checker
.settings .settings()
.flake8_tidy_imports .flake8_tidy_imports
.banned_module_level_imports(), .banned_module_level_imports(),
) { ) {

2
crates/ruff_linter/src/rules/flake8_type_checking/rules/runtime_import_in_type_checking_block.rs
View file

@ -164,7 +164,7 @@ pub(crate) fn runtime_import_in_type_checking_block(checker: &Checker, scope: &S
// since some people will consistently use their // since some people will consistently use their
// type aliases at runtimes, while others won't, so // type aliases at runtimes, while others won't, so
// the best solution is unclear. // the best solution is unclear.
if checker.settings.flake8_type_checking.quote_annotations if checker.settings().flake8_type_checking.quote_annotations
&& binding.references().all(|reference_id| { && binding.references().all(|reference_id| {
let reference = checker.semantic().reference(reference_id); let reference = checker.semantic().reference(reference_id);
reference.in_typing_context() || reference.in_runtime_evaluated_annotation() reference.in_typing_context() || reference.in_runtime_evaluated_annotation()

20
crates/ruff_linter/src/rules/flake8_type_checking/rules/typing_only_runtime_import.rs
View file

@ -273,7 +273,7 @@ pub(crate) fn typing_only_runtime_import(
// If we're in un-strict mode, don't flag typing-only imports that are // If we're in un-strict mode, don't flag typing-only imports that are
// implicitly loaded by way of a valid runtime import. // implicitly loaded by way of a valid runtime import.
if !checker.settings.flake8_type_checking.strict if !checker.settings().flake8_type_checking.strict
&& runtime_imports && runtime_imports
.iter() .iter()
.any(|import| is_implicit_import(binding, import)) .any(|import| is_implicit_import(binding, import))
@ -294,7 +294,7 @@ pub(crate) fn typing_only_runtime_import(
.references() .references()
.map(|reference_id| checker.semantic().reference(reference_id)) .map(|reference_id| checker.semantic().reference(reference_id))
.all(|reference| { .all(|reference| {
is_typing_reference(reference, &checker.settings.flake8_type_checking) is_typing_reference(reference, &checker.settings().flake8_type_checking)
}) })
{ {
let qualified_name = import.qualified_name(); let qualified_name = import.qualified_name();
@ -302,7 +302,7 @@ pub(crate) fn typing_only_runtime_import(
if is_exempt( if is_exempt(
&qualified_name.to_string(), &qualified_name.to_string(),
&checker &checker
.settings .settings()
.flake8_type_checking .flake8_type_checking
.exempt_modules .exempt_modules
.iter() .iter()
@ -316,7 +316,7 @@ pub(crate) fn typing_only_runtime_import(
// Categorize the import, using coarse-grained categorization. // Categorize the import, using coarse-grained categorization.
let match_source_strategy = let match_source_strategy =
if is_full_path_match_source_strategy_enabled(checker.settings) { if is_full_path_match_source_strategy_enabled(checker.settings()) {
MatchSourceStrategy::FullPath MatchSourceStrategy::FullPath
} else { } else {
MatchSourceStrategy::Root MatchSourceStrategy::Root
@ -325,14 +325,14 @@ pub(crate) fn typing_only_runtime_import(
let import_type = match categorize( let import_type = match categorize(
&source_name, &source_name,
qualified_name.is_unresolved_import(), qualified_name.is_unresolved_import(),
&checker.settings.src, &checker.settings().src,
checker.package(), checker.package(),
checker.settings.isort.detect_same_package, checker.settings().isort.detect_same_package,
&checker.settings.isort.known_modules, &checker.settings().isort.known_modules,
checker.target_version(), checker.target_version(),
checker.settings.isort.no_sections, checker.settings().isort.no_sections,
&checker.settings.isort.section_order, &checker.settings().isort.section_order,
&checker.settings.isort.default_section, &checker.settings().isort.default_section,
match_source_strategy, match_source_strategy,
) { ) {
ImportSection::Known(ImportType::LocalFolder | ImportType::FirstParty) => { ImportSection::Known(ImportType::LocalFolder | ImportType::FirstParty) => {

10
crates/ruff_linter/src/rules/flake8_unused_arguments/rules/unused_arguments.rs
View file

@ -250,7 +250,7 @@ impl Argumentable {
/// Check a plain function for unused arguments. /// Check a plain function for unused arguments.
fn function(argumentable: Argumentable, parameters: &Parameters, scope: &Scope, checker: &Checker) { fn function(argumentable: Argumentable, parameters: &Parameters, scope: &Scope, checker: &Checker) {
let ignore_variadic_names = checker let ignore_variadic_names = checker
.settings .settings()
.flake8_unused_arguments .flake8_unused_arguments
.ignore_variadic_names; .ignore_variadic_names;
let args = parameters let args = parameters
@ -276,7 +276,7 @@ fn function(argumentable: Argumentable, parameters: &Parameters, scope: &Scope,
/// Check a method for unused arguments. /// Check a method for unused arguments.
fn method(argumentable: Argumentable, parameters: &Parameters, scope: &Scope, checker: &Checker) { fn method(argumentable: Argumentable, parameters: &Parameters, scope: &Scope, checker: &Checker) {
let ignore_variadic_names = checker let ignore_variadic_names = checker
.settings .settings()
.flake8_unused_arguments .flake8_unused_arguments
.ignore_variadic_names; .ignore_variadic_names;
let args = parameters let args = parameters
@ -307,7 +307,7 @@ fn call<'a>(
checker: &Checker, checker: &Checker,
) { ) {
let semantic = checker.semantic(); let semantic = checker.semantic();
let dummy_variable_rgx = &checker.settings.dummy_variable_rgx; let dummy_variable_rgx = &checker.settings().dummy_variable_rgx;
for arg in parameters { for arg in parameters {
let Some(binding) = scope let Some(binding) = scope
.get(arg.name()) .get(arg.name())
@ -408,8 +408,8 @@ pub(crate) fn unused_arguments(checker: &Checker, scope: &Scope) {
decorator_list, decorator_list,
parent, parent,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
) { ) {
function_type::FunctionType::Function => { function_type::FunctionType::Function => {
if checker.is_rule_enabled(Argumentable::Function.rule_code()) if checker.is_rule_enabled(Argumentable::Function.rule_code())

4
crates/ruff_linter/src/rules/pep8_naming/rules/camelcase_imported_as_acronym.rs
View file

@ -68,7 +68,7 @@ pub(crate) fn camelcase_imported_as_acronym(
&& str::is_cased_uppercase(asname) && str::is_cased_uppercase(asname)
&& helpers::is_acronym(name, asname) && helpers::is_acronym(name, asname)
{ {
let ignore_names = &checker.settings.pep8_naming.ignore_names; let ignore_names = &checker.settings().pep8_naming.ignore_names;
// Ignore any explicitly-allowed names. // Ignore any explicitly-allowed names.
if ignore_names.matches(name) || ignore_names.matches(asname) { if ignore_names.matches(name) || ignore_names.matches(asname) {
@ -114,7 +114,7 @@ fn is_ignored_because_of_import_convention(
// Ignore names that follow a community-agreed import convention. // Ignore names that follow a community-agreed import convention.
checker checker
.settings .settings()
.flake8_import_conventions .flake8_import_conventions
.aliases .aliases
.get(&*full_name) .get(&*full_name)

2
crates/ruff_linter/src/rules/pep8_naming/rules/invalid_argument_name.rs
View file

@ -81,7 +81,7 @@ pub(crate) fn invalid_argument_name_lambda(checker: &Checker, lambda: &ExprLambd
/// N803 /// N803
fn invalid_argument_name(checker: &Checker, parameters: &Parameters) { fn invalid_argument_name(checker: &Checker, parameters: &Parameters) {
let ignore_names = &checker.settings.pep8_naming.ignore_names; let ignore_names = &checker.settings().pep8_naming.ignore_names;
for parameter in parameters { for parameter in parameters {
let name = parameter.name().as_str(); let name = parameter.name().as_str();

6
crates/ruff_linter/src/rules/pep8_naming/rules/invalid_first_argument_name.rs
View file

@ -226,8 +226,8 @@ pub(crate) fn invalid_first_argument_name(checker: &Checker, scope: &Scope) {
decorator_list, decorator_list,
parent_scope, parent_scope,
semantic, semantic,
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
) { ) {
function_type::FunctionType::Function | function_type::FunctionType::StaticMethod => { function_type::FunctionType::Function | function_type::FunctionType::StaticMethod => {
return; return;
@ -260,7 +260,7 @@ pub(crate) fn invalid_first_argument_name(checker: &Checker, scope: &Scope) {
if &self_or_cls.name == function_type.valid_first_argument_name() if &self_or_cls.name == function_type.valid_first_argument_name()
|| checker || checker
.settings .settings()
.pep8_naming .pep8_naming
.ignore_names .ignore_names
.matches(&self_or_cls.name) .matches(&self_or_cls.name)

2
crates/ruff_linter/src/rules/pep8_naming/rules/mixed_case_variable_in_class_scope.rs
View file

@ -72,7 +72,7 @@ pub(crate) fn mixed_case_variable_in_class_scope(
return; return;
} }
if checker.settings.pep8_naming.ignore_names.matches(name) { if checker.settings().pep8_naming.ignore_names.matches(name) {
return; return;
} }

2
crates/ruff_linter/src/rules/pep8_naming/rules/mixed_case_variable_in_global_scope.rs
View file

@ -75,7 +75,7 @@ pub(crate) fn mixed_case_variable_in_global_scope(checker: &Checker, expr: &Expr
return; return;
} }
if checker.settings.pep8_naming.ignore_names.matches(name) { if checker.settings().pep8_naming.ignore_names.matches(name) {
return; return;
} }

2
crates/ruff_linter/src/rules/pep8_naming/rules/non_lowercase_variable_in_function.rs
View file

@ -77,7 +77,7 @@ pub(crate) fn non_lowercase_variable_in_function(checker: &Checker, expr: &Expr,
} }
// Ignore explicitly-allowed names. // Ignore explicitly-allowed names.
if checker.settings.pep8_naming.ignore_names.matches(name) { if checker.settings().pep8_naming.ignore_names.matches(name) {
return; return;
} }

2
crates/ruff_linter/src/rules/perflint/rules/manual_dict_comprehension.rs
View file

@ -235,7 +235,7 @@ pub(crate) fn manual_dict_comprehension(checker: &Checker, for_stmt: &ast::StmtF
return; return;
} }
if is_fix_manual_dict_comprehension_enabled(checker.settings) { if is_fix_manual_dict_comprehension_enabled(checker.settings()) {
let binding_stmt = binding.statement(checker.semantic()); let binding_stmt = binding.statement(checker.semantic());
let binding_value = binding_stmt.and_then(|binding_stmt| match binding_stmt { let binding_value = binding_stmt.and_then(|binding_stmt| match binding_stmt {
ast::Stmt::AnnAssign(assign) => assign.value.as_deref(), ast::Stmt::AnnAssign(assign) => assign.value.as_deref(),

2
crates/ruff_linter/src/rules/perflint/rules/manual_list_comprehension.rs
View file

@ -337,7 +337,7 @@ pub(crate) fn manual_list_comprehension(checker: &Checker, for_stmt: &ast::StmtF
); );
// TODO: once this fix is stabilized, change the rule to always fixable // TODO: once this fix is stabilized, change the rule to always fixable
if is_fix_manual_list_comprehension_enabled(checker.settings) { if is_fix_manual_list_comprehension_enabled(checker.settings()) {
diagnostic.try_set_fix(|| { diagnostic.try_set_fix(|| {
convert_to_list_extend( convert_to_list_extend(
comprehension_type, comprehension_type,

4
crates/ruff_linter/src/rules/pydoclint/rules/check_docstring.rs
View file

@ -887,7 +887,7 @@ pub(crate) fn check_docstring(
return; return;
}; };
if checker.settings.pydoclint.ignore_one_line_docstrings && is_one_line(docstring) { if checker.settings().pydoclint.ignore_one_line_docstrings && is_one_line(docstring) {
return; return;
} }
@ -919,7 +919,7 @@ pub(crate) fn check_docstring(
if should_document_returns(function_def) if should_document_returns(function_def)
&& !returns_documented(docstring, &docstring_sections, convention) && !returns_documented(docstring, &docstring_sections, convention)
{ {
let extra_property_decorators = checker.settings.pydocstyle.property_decorators(); let extra_property_decorators = checker.settings().pydocstyle.property_decorators();
if !definition.is_property(extra_property_decorators, semantic) { if !definition.is_property(extra_property_decorators, semantic) {
if !body_entries.returns.is_empty() { if !body_entries.returns.is_empty() {
match function_def.returns.as_deref() { match function_def.returns.as_deref() {

2
crates/ruff_linter/src/rules/pydocstyle/rules/sections.rs
View file

@ -1789,7 +1789,7 @@ fn missing_args(checker: &Checker, docstring: &Docstring, docstrings_args: &FxHa
// Check specifically for `vararg` and `kwarg`, which can be prefixed with a // Check specifically for `vararg` and `kwarg`, which can be prefixed with a
// single or double star, respectively. // single or double star, respectively.
if !checker.settings.pydocstyle.ignore_var_parameters() { if !checker.settings().pydocstyle.ignore_var_parameters() {
if let Some(arg) = function.parameters.vararg.as_ref() { if let Some(arg) = function.parameters.vararg.as_ref() {
let arg_name = arg.name.as_str(); let arg_name = arg.name.as_str();
let starred_arg_name = format!("*{arg_name}"); let starred_arg_name = format!("*{arg_name}");

2
crates/ruff_linter/src/rules/pyflakes/rules/unused_annotation.rs
View file

@ -39,7 +39,7 @@ pub(crate) fn unused_annotation(checker: &Checker, scope: &Scope) {
let binding = checker.semantic().binding(binding_id); let binding = checker.semantic().binding(binding_id);
if binding.kind.is_annotation() if binding.kind.is_annotation()
&& binding.is_unused() && binding.is_unused()
&& !checker.settings.dummy_variable_rgx.is_match(name) && !checker.settings().dummy_variable_rgx.is_match(name)
{ {
Some((name.to_string(), binding.range())) Some((name.to_string(), binding.range()))
} else { } else {

22
crates/ruff_linter/src/rules/pyflakes/rules/unused_import.rs
View file

@ -231,7 +231,7 @@ enum UnusedImportContext {
fn is_first_party(import: &AnyImport, checker: &Checker) -> bool { fn is_first_party(import: &AnyImport, checker: &Checker) -> bool {
let source_name = import.source_name().join("."); let source_name = import.source_name().join(".");
let match_source_strategy = if is_full_path_match_source_strategy_enabled(checker.settings) { let match_source_strategy = if is_full_path_match_source_strategy_enabled(checker.settings()) {
MatchSourceStrategy::FullPath MatchSourceStrategy::FullPath
} else { } else {
MatchSourceStrategy::Root MatchSourceStrategy::Root
@ -239,14 +239,14 @@ fn is_first_party(import: &AnyImport, checker: &Checker) -> bool {
let category = isort::categorize( let category = isort::categorize(
&source_name, &source_name,
import.qualified_name().is_unresolved_import(), import.qualified_name().is_unresolved_import(),
&checker.settings.src, &checker.settings().src,
checker.package(), checker.package(),
checker.settings.isort.detect_same_package, checker.settings().isort.detect_same_package,
&checker.settings.isort.known_modules, &checker.settings().isort.known_modules,
checker.target_version(), checker.target_version(),
checker.settings.isort.no_sections, checker.settings().isort.no_sections,
&checker.settings.isort.section_order, &checker.settings().isort.section_order,
&checker.settings.isort.default_section, &checker.settings().isort.default_section,
match_source_strategy, match_source_strategy,
); );
matches! { matches! {
@ -317,7 +317,7 @@ pub(crate) fn unused_import(checker: &Checker, scope: &Scope) {
// If an import is marked as required, avoid treating it as unused, regardless of whether // If an import is marked as required, avoid treating it as unused, regardless of whether
// it was _actually_ used. // it was _actually_ used.
if checker if checker
.settings .settings()
.isort .isort
.required_imports .required_imports
.iter() .iter()
@ -328,7 +328,7 @@ pub(crate) fn unused_import(checker: &Checker, scope: &Scope) {
// If an import was marked as allowed, avoid treating it as unused. // If an import was marked as allowed, avoid treating it as unused.
if checker if checker
.settings .settings()
.pyflakes .pyflakes
.allowed_unused_imports .allowed_unused_imports
.iter() .iter()
@ -366,8 +366,8 @@ pub(crate) fn unused_import(checker: &Checker, scope: &Scope) {
} }
let in_init = checker.path().ends_with("__init__.py"); let in_init = checker.path().ends_with("__init__.py");
let fix_init = !checker.settings.ignore_init_module_imports; let fix_init = !checker.settings().ignore_init_module_imports;
let preview_mode = is_dunder_init_fix_unused_import_enabled(checker.settings); let preview_mode = is_dunder_init_fix_unused_import_enabled(checker.settings());
let dunder_all_exprs = find_dunder_all_exprs(checker.semantic()); let dunder_all_exprs = find_dunder_all_exprs(checker.semantic());
// Generate a diagnostic for every import, but share fixes across all imports within the same // Generate a diagnostic for every import, but share fixes across all imports within the same

2
crates/ruff_linter/src/rules/pyflakes/rules/unused_variable.rs
View file

@ -187,7 +187,7 @@ fn remove_unused_variable(binding: &Binding, checker: &Checker) -> Option<Fix> {
} else { } else {
let name = binding.name(checker.source()); let name = binding.name(checker.source());
let renamed = format!("_{name}"); let renamed = format!("_{name}");
if checker.settings.dummy_variable_rgx.is_match(&renamed) { if checker.settings().dummy_variable_rgx.is_match(&renamed) {
let edit = Edit::range_replacement(renamed, binding.range()); let edit = Edit::range_replacement(renamed, binding.range());
return Some(Fix::unsafe_edit(edit).isolate(isolation)); return Some(Fix::unsafe_edit(edit).isolate(isolation));

2
crates/ruff_linter/src/rules/pylint/rules/bad_dunder_method_name.rs
View file

@ -69,7 +69,7 @@ pub(crate) fn bad_dunder_method_name(checker: &Checker, method: &ast::StmtFuncti
// If the name is explicitly allowed, skip it. // If the name is explicitly allowed, skip it.
if is_known_dunder_method(&method.name) if is_known_dunder_method(&method.name)
|| checker || checker
.settings .settings()
.pylint .pylint
.allow_dunder_method_names .allow_dunder_method_names
.contains(method.name.as_str()) .contains(method.name.as_str())

4
crates/ruff_linter/src/rules/pylint/rules/bad_staticmethod_argument.rs
View file

@ -71,8 +71,8 @@ pub(crate) fn bad_staticmethod_argument(checker: &Checker, scope: &Scope) {
decorator_list, decorator_list,
parent, parent,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
match type_ { match type_ {

2
crates/ruff_linter/src/rules/pylint/rules/import_outside_top_level.rs
View file

@ -91,7 +91,7 @@ fn is_banned_module_level_import(policy: &NameMatchPolicy, checker: &Checker) ->
policy policy
.find( .find(
checker checker
.settings .settings()
.flake8_tidy_imports .flake8_tidy_imports
.banned_module_level_imports(), .banned_module_level_imports(),
) )

2
crates/ruff_linter/src/rules/pylint/rules/logging.rs
View file

@ -109,7 +109,7 @@ pub(crate) fn logging_call(checker: &Checker, call: &ast::ExprCall) {
if !logging::is_logger_candidate( if !logging::is_logger_candidate(
&call.func, &call.func,
checker.semantic(), checker.semantic(),
&checker.settings.logger_objects, &checker.settings().logger_objects,
) { ) {
return; return;
} }

2
crates/ruff_linter/src/rules/pylint/rules/magic_value_comparison.rs
View file

@ -110,7 +110,7 @@ pub(crate) fn magic_value_comparison(checker: &Checker, left: &Expr, comparators
for comparison_expr in std::iter::once(left).chain(comparators) { for comparison_expr in std::iter::once(left).chain(comparators) {
if let Some(value) = as_literal(comparison_expr) { if let Some(value) = as_literal(comparison_expr) {
if is_magic_value(value, &checker.settings.pylint.allow_magic_value_types) { if is_magic_value(value, &checker.settings().pylint.allow_magic_value_types) {
checker.report_diagnostic( checker.report_diagnostic(
MagicValueComparison { MagicValueComparison {
value: checker.locator().slice(comparison_expr).to_string(), value: checker.locator().slice(comparison_expr).to_string(),

2
crates/ruff_linter/src/rules/pylint/rules/misplaced_bare_raise.rs
View file

@ -60,7 +60,7 @@ pub(crate) fn misplaced_bare_raise(checker: &Checker, raise: &ast::StmtRaise) {
return; return;
} }
if in_dunder_method("__exit__", checker.semantic(), checker.settings) { if in_dunder_method("__exit__", checker.semantic(), checker.settings()) {
return; return;
} }

6
crates/ruff_linter/src/rules/pylint/rules/no_self_use.rs
View file

@ -76,15 +76,15 @@ pub(crate) fn no_self_use(checker: &Checker, scope_id: ScopeId, scope: &Scope) {
decorator_list, decorator_list,
parent, parent,
semantic, semantic,
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
), ),
function_type::FunctionType::Method function_type::FunctionType::Method
) { ) {
return; return;
} }
let extra_property_decorators = checker.settings.pydocstyle.property_decorators(); let extra_property_decorators = checker.settings().pydocstyle.property_decorators();
if function_type::is_stub(func, semantic) if function_type::is_stub(func, semantic)
|| visibility::is_magic(name) || visibility::is_magic(name)

2
crates/ruff_linter/src/rules/pylint/rules/property_with_parameters.rs
View file

@ -55,7 +55,7 @@ pub(crate) fn property_with_parameters(
return; return;
} }
let semantic = checker.semantic(); let semantic = checker.semantic();
let extra_property_decorators = checker.settings.pydocstyle.property_decorators(); let extra_property_decorators = checker.settings().pydocstyle.property_decorators();
if is_property(decorator_list, extra_property_decorators, semantic) { if is_property(decorator_list, extra_property_decorators, semantic) {
checker.report_diagnostic(PropertyWithParameters, stmt.identifier()); checker.report_diagnostic(PropertyWithParameters, stmt.identifier());
} }

2
crates/ruff_linter/src/rules/pylint/rules/redeclared_assigned_name.rs
View file

@ -65,7 +65,7 @@ fn check_expr(checker: &Checker, expr: &Expr, names: &mut Vec<Name>) {
check_expr(checker, &starred.value, names); check_expr(checker, &starred.value, names);
} }
Expr::Name(ast::ExprName { id, .. }) => { Expr::Name(ast::ExprName { id, .. }) => {
if checker.settings.dummy_variable_rgx.is_match(id) { if checker.settings().dummy_variable_rgx.is_match(id) {
// Ignore dummy variable assignments // Ignore dummy variable assignments
return; return;
} }

8
crates/ruff_linter/src/rules/pylint/rules/redefined_loop_name.rs
View file

@ -346,7 +346,7 @@ pub(crate) fn redefined_loop_name(checker: &Checker, stmt: &Stmt) {
let (outer_assignment_targets, inner_assignment_targets) = match stmt { let (outer_assignment_targets, inner_assignment_targets) = match stmt {
Stmt::With(ast::StmtWith { items, body, .. }) => { Stmt::With(ast::StmtWith { items, body, .. }) => {
let outer_assignment_targets: Vec<ExprWithOuterBindingKind> = let outer_assignment_targets: Vec<ExprWithOuterBindingKind> =
assignment_targets_from_with_items(items, &checker.settings.dummy_variable_rgx) assignment_targets_from_with_items(items, &checker.settings().dummy_variable_rgx)
.map(|expr| ExprWithOuterBindingKind { .map(|expr| ExprWithOuterBindingKind {
expr, expr,
binding_kind: OuterBindingKind::With, binding_kind: OuterBindingKind::With,
@ -354,7 +354,7 @@ pub(crate) fn redefined_loop_name(checker: &Checker, stmt: &Stmt) {
.collect(); .collect();
let mut visitor = InnerForWithAssignTargetsVisitor { let mut visitor = InnerForWithAssignTargetsVisitor {
context: checker.semantic(), context: checker.semantic(),
dummy_variable_rgx: &checker.settings.dummy_variable_rgx, dummy_variable_rgx: &checker.settings().dummy_variable_rgx,
assignment_targets: vec![], assignment_targets: vec![],
}; };
for stmt in body { for stmt in body {
@ -364,7 +364,7 @@ pub(crate) fn redefined_loop_name(checker: &Checker, stmt: &Stmt) {
} }
Stmt::For(ast::StmtFor { target, body, .. }) => { Stmt::For(ast::StmtFor { target, body, .. }) => {
let outer_assignment_targets: Vec<ExprWithOuterBindingKind> = let outer_assignment_targets: Vec<ExprWithOuterBindingKind> =
assignment_targets_from_expr(target, &checker.settings.dummy_variable_rgx) assignment_targets_from_expr(target, &checker.settings().dummy_variable_rgx)
.map(|expr| ExprWithOuterBindingKind { .map(|expr| ExprWithOuterBindingKind {
expr, expr,
binding_kind: OuterBindingKind::For, binding_kind: OuterBindingKind::For,
@ -372,7 +372,7 @@ pub(crate) fn redefined_loop_name(checker: &Checker, stmt: &Stmt) {
.collect(); .collect();
let mut visitor = InnerForWithAssignTargetsVisitor { let mut visitor = InnerForWithAssignTargetsVisitor {
context: checker.semantic(), context: checker.semantic(),
dummy_variable_rgx: &checker.settings.dummy_variable_rgx, dummy_variable_rgx: &checker.settings().dummy_variable_rgx,
assignment_targets: vec![], assignment_targets: vec![],
}; };
for stmt in body { for stmt in body {

2
crates/ruff_linter/src/rules/pylint/rules/return_in_init.rs
View file

@ -63,7 +63,7 @@ pub(crate) fn return_in_init(checker: &Checker, stmt: &Stmt) {
} }
} }
if in_dunder_method("__init__", checker.semantic(), checker.settings) { if in_dunder_method("__init__", checker.semantic(), checker.settings()) {
checker.report_diagnostic(ReturnInInit, stmt.range()); checker.report_diagnostic(ReturnInInit, stmt.range());
} }
} }

4
crates/ruff_linter/src/rules/pylint/rules/self_or_cls_assignment.rs
View file

@ -98,8 +98,8 @@ pub(crate) fn self_or_cls_assignment(checker: &Checker, target: &Expr) {
decorator_list, decorator_list,
parent, parent,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
let method_type = match (function_type, self_or_cls.name().as_str()) { let method_type = match (function_type, self_or_cls.name().as_str()) {

4
crates/ruff_linter/src/rules/pylint/rules/singledispatch_method.rs
View file

@ -79,8 +79,8 @@ pub(crate) fn singledispatch_method(checker: &Checker, scope: &Scope) {
decorator_list, decorator_list,
parent, parent,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
if !matches!( if !matches!(
type_, type_,

4
crates/ruff_linter/src/rules/pylint/rules/singledispatchmethod_function.rs
View file

@ -77,8 +77,8 @@ pub(crate) fn singledispatchmethod_function(checker: &Checker, scope: &Scope) {
decorator_list, decorator_list,
parent, parent,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
if !matches!(type_, function_type::FunctionType::Function) { if !matches!(type_, function_type::FunctionType::Function) {
return; return;

4
crates/ruff_linter/src/rules/pylint/rules/super_without_brackets.rs
View file

@ -96,8 +96,8 @@ pub(crate) fn super_without_brackets(checker: &Checker, func: &Expr) {
&function_def.decorator_list, &function_def.decorator_list,
parent, parent,
checker.semantic(), checker.semantic(),
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
); );
if !matches!( if !matches!(
classification, classification,

12
crates/ruff_linter/src/rules/pylint/rules/too_many_arguments.rs
View file

@ -68,10 +68,10 @@ pub(crate) fn too_many_arguments(checker: &Checker, function_def: &ast::StmtFunc
let num_arguments = function_def let num_arguments = function_def
.parameters .parameters
.iter_non_variadic_params() .iter_non_variadic_params()
.filter(|param| !checker.settings.dummy_variable_rgx.is_match(param.name())) .filter(|param| !checker.settings().dummy_variable_rgx.is_match(param.name()))
.count(); .count();
if num_arguments <= checker.settings.pylint.max_args { if num_arguments <= checker.settings().pylint.max_args {
return; return;
} }
@ -90,8 +90,8 @@ pub(crate) fn too_many_arguments(checker: &Checker, function_def: &ast::StmtFunc
&function_def.decorator_list, &function_def.decorator_list,
semantic.current_scope(), semantic.current_scope(),
semantic, semantic,
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
), ),
function_type::FunctionType::Method function_type::FunctionType::Method
| function_type::FunctionType::ClassMethod | function_type::FunctionType::ClassMethod
@ -104,14 +104,14 @@ pub(crate) fn too_many_arguments(checker: &Checker, function_def: &ast::StmtFunc
num_arguments num_arguments
}; };
if num_arguments <= checker.settings.pylint.max_args { if num_arguments <= checker.settings().pylint.max_args {
return; return;
} }
checker.report_diagnostic( checker.report_diagnostic(
TooManyArguments { TooManyArguments {
c_args: num_arguments, c_args: num_arguments,
max_args: checker.settings.pylint.max_args, max_args: checker.settings().pylint.max_args,
}, },
function_def.identifier(), function_def.identifier(),
); );

8
crates/ruff_linter/src/rules/pylint/rules/too_many_boolean_expressions.rs
View file

@ -46,11 +46,11 @@ impl Violation for TooManyBooleanExpressions {
pub(crate) fn too_many_boolean_expressions(checker: &Checker, stmt: &StmtIf) { pub(crate) fn too_many_boolean_expressions(checker: &Checker, stmt: &StmtIf) {
if let Some(bool_op) = stmt.test.as_bool_op_expr() { if let Some(bool_op) = stmt.test.as_bool_op_expr() {
let expressions = count_bools(bool_op); let expressions = count_bools(bool_op);
if expressions > checker.settings.pylint.max_bool_expr { if expressions > checker.settings().pylint.max_bool_expr {
checker.report_diagnostic( checker.report_diagnostic(
TooManyBooleanExpressions { TooManyBooleanExpressions {
expressions, expressions,
max_expressions: checker.settings.pylint.max_bool_expr, max_expressions: checker.settings().pylint.max_bool_expr,
}, },
bool_op.range(), bool_op.range(),
); );
@ -60,11 +60,11 @@ pub(crate) fn too_many_boolean_expressions(checker: &Checker, stmt: &StmtIf) {
for elif in &stmt.elif_else_clauses { for elif in &stmt.elif_else_clauses {
if let Some(bool_op) = elif.test.as_ref().and_then(Expr::as_bool_op_expr) { if let Some(bool_op) = elif.test.as_ref().and_then(Expr::as_bool_op_expr) {
let expressions = count_bools(bool_op); let expressions = count_bools(bool_op);
if expressions > checker.settings.pylint.max_bool_expr { if expressions > checker.settings().pylint.max_bool_expr {
checker.report_diagnostic( checker.report_diagnostic(
TooManyBooleanExpressions { TooManyBooleanExpressions {
expressions, expressions,
max_expressions: checker.settings.pylint.max_bool_expr, max_expressions: checker.settings().pylint.max_bool_expr,
}, },
bool_op.range(), bool_op.range(),
); );

4
crates/ruff_linter/src/rules/pylint/rules/too_many_locals.rs
View file

@ -45,12 +45,12 @@ pub(crate) fn too_many_locals(checker: &Checker, scope: &Scope) {
binding.kind.is_assignment() binding.kind.is_assignment()
}) })
.count(); .count();
if num_locals > checker.settings.pylint.max_locals { if num_locals > checker.settings().pylint.max_locals {
if let ScopeKind::Function(func) = scope.kind { if let ScopeKind::Function(func) = scope.kind {
checker.report_diagnostic( checker.report_diagnostic(
TooManyLocals { TooManyLocals {
current_amount: num_locals, current_amount: num_locals,
max_amount: checker.settings.pylint.max_locals, max_amount: checker.settings().pylint.max_locals,
}, },
func.identifier(), func.identifier(),
); );

2
crates/ruff_linter/src/rules/pylint/rules/too_many_nested_blocks.rs
View file

@ -48,7 +48,7 @@ pub(crate) fn too_many_nested_blocks(checker: &Checker, stmt: &Stmt) {
return; return;
} }
let max_nested_blocks = checker.settings.pylint.max_nested_blocks; let max_nested_blocks = checker.settings().pylint.max_nested_blocks;
// Traverse up the hierarchy, identifying the root node and counting the number of nested // Traverse up the hierarchy, identifying the root node and counting the number of nested
// blocks between the root and this leaf. // blocks between the root and this leaf.

12
crates/ruff_linter/src/rules/pylint/rules/too_many_positional_arguments.rs
View file

@ -72,10 +72,10 @@ pub(crate) fn too_many_positional_arguments(
.posonlyargs .posonlyargs
.iter() .iter()
.chain(&function_def.parameters.args) .chain(&function_def.parameters.args)
.filter(|param| !checker.settings.dummy_variable_rgx.is_match(param.name())) .filter(|param| !checker.settings().dummy_variable_rgx.is_match(param.name()))
.count(); .count();
if num_positional_args <= checker.settings.pylint.max_positional_args { if num_positional_args <= checker.settings().pylint.max_positional_args {
return; return;
} }
@ -94,8 +94,8 @@ pub(crate) fn too_many_positional_arguments(
&function_def.decorator_list, &function_def.decorator_list,
semantic.current_scope(), semantic.current_scope(),
semantic, semantic,
&checker.settings.pep8_naming.classmethod_decorators, &checker.settings().pep8_naming.classmethod_decorators,
&checker.settings.pep8_naming.staticmethod_decorators, &checker.settings().pep8_naming.staticmethod_decorators,
), ),
function_type::FunctionType::Method function_type::FunctionType::Method
| function_type::FunctionType::ClassMethod | function_type::FunctionType::ClassMethod
@ -108,14 +108,14 @@ pub(crate) fn too_many_positional_arguments(
num_positional_args num_positional_args
}; };
if num_positional_args <= checker.settings.pylint.max_positional_args { if num_positional_args <= checker.settings().pylint.max_positional_args {
return; return;
} }
checker.report_diagnostic( checker.report_diagnostic(
TooManyPositionalArguments { TooManyPositionalArguments {
c_pos: num_positional_args, c_pos: num_positional_args,
max_pos: checker.settings.pylint.max_positional_args, max_pos: checker.settings().pylint.max_positional_args,
}, },
function_def.identifier(), function_def.identifier(),
); );

6
crates/ruff_linter/src/rules/pylint/rules/useless_import_alias.rs
View file

@ -75,7 +75,7 @@ pub(crate) fn useless_import_alias(checker: &Checker, alias: &Alias) {
// A re-export in __init__.py is probably intentional. // A re-export in __init__.py is probably intentional.
if checker.path().ends_with("__init__.py") if checker.path().ends_with("__init__.py")
&& is_ignore_init_files_in_useless_alias_enabled(checker.settings) && is_ignore_init_files_in_useless_alias_enabled(checker.settings())
{ {
return; return;
} }
@ -83,7 +83,7 @@ pub(crate) fn useless_import_alias(checker: &Checker, alias: &Alias) {
// A required import with a useless alias causes an infinite loop. // A required import with a useless alias causes an infinite loop.
// See https://github.com/astral-sh/ruff/issues/14283 // See https://github.com/astral-sh/ruff/issues/14283
let required_import_conflict = checker let required_import_conflict = checker
.settings .settings()
.isort .isort
.requires_module_import(alias.name.to_string(), Some(asname.to_string())); .requires_module_import(alias.name.to_string(), Some(asname.to_string()));
let mut diagnostic = checker.report_diagnostic( let mut diagnostic = checker.report_diagnostic(
@ -121,7 +121,7 @@ pub(crate) fn useless_import_from_alias(
// A required import with a useless alias causes an infinite loop. // A required import with a useless alias causes an infinite loop.
// See https://github.com/astral-sh/ruff/issues/14283 // See https://github.com/astral-sh/ruff/issues/14283
let required_import_conflict = checker.settings.isort.requires_member_import( let required_import_conflict = checker.settings().isort.requires_member_import(
module.map(str::to_string), module.map(str::to_string),
alias.name.to_string(), alias.name.to_string(),
Some(asname.to_string()), Some(asname.to_string()),

2
crates/ruff_linter/src/rules/pylint/rules/yield_in_init.rs
View file

@ -40,7 +40,7 @@ impl Violation for YieldInInit {
/// PLE0100 /// PLE0100
pub(crate) fn yield_in_init(checker: &Checker, expr: &Expr) { pub(crate) fn yield_in_init(checker: &Checker, expr: &Expr) {
if in_dunder_method("__init__", checker.semantic(), checker.settings) { if in_dunder_method("__init__", checker.semantic(), checker.settings()) {
checker.report_diagnostic(YieldInInit, expr.range()); checker.report_diagnostic(YieldInInit, expr.range());
} }
} }

4
crates/ruff_linter/src/rules/ruff/rules/access_annotations_from_class_dict.rs
View file

@ -97,7 +97,7 @@ impl Violation for AccessAnnotationsFromClassDict {
/// RUF063 /// RUF063
pub(crate) fn access_annotations_from_class_dict_with_get(checker: &Checker, call: &ExprCall) { pub(crate) fn access_annotations_from_class_dict_with_get(checker: &Checker, call: &ExprCall) {
let python_version = checker.target_version(); let python_version = checker.target_version();
let typing_extensions = checker.settings.typing_extensions; let typing_extensions = checker.settings().typing_extensions;
// Only apply this rule for Python 3.10 and newer unless `typing-extensions` is enabled. // Only apply this rule for Python 3.10 and newer unless `typing-extensions` is enabled.
if python_version < PythonVersion::PY310 && !typing_extensions { if python_version < PythonVersion::PY310 && !typing_extensions {
@ -152,7 +152,7 @@ pub(crate) fn access_annotations_from_class_dict_by_key(
subscript: &ExprSubscript, subscript: &ExprSubscript,
) { ) {
let python_version = checker.target_version(); let python_version = checker.target_version();
let typing_extensions = checker.settings.typing_extensions; let typing_extensions = checker.settings().typing_extensions;
// Only apply this rule for Python 3.10 and newer unless `typing-extensions` is enabled. // Only apply this rule for Python 3.10 and newer unless `typing-extensions` is enabled.
if python_version < PythonVersion::PY310 && !typing_extensions { if python_version < PythonVersion::PY310 && !typing_extensions {

6
crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs
View file

@ -205,7 +205,7 @@ pub(crate) fn ambiguous_unicode_character_string(checker: &Checker, string_like:
ast::StringLikePart::String(string_literal) => { ast::StringLikePart::String(string_literal) => {
let text = checker.locator().slice(string_literal); let text = checker.locator().slice(string_literal);
for candidate in for candidate in
ambiguous_unicode_character(text, string_literal.range(), checker.settings) ambiguous_unicode_character(text, string_literal.range(), checker.settings())
{ {
candidate.report_diagnostic(checker, context); candidate.report_diagnostic(checker, context);
} }
@ -216,7 +216,7 @@ pub(crate) fn ambiguous_unicode_character_string(checker: &Checker, string_like:
for literal in elements.literals() { for literal in elements.literals() {
let text = checker.locator().slice(literal); let text = checker.locator().slice(literal);
for candidate in for candidate in
ambiguous_unicode_character(text, literal.range(), checker.settings) ambiguous_unicode_character(text, literal.range(), checker.settings())
{ {
candidate.report_diagnostic(checker, context); candidate.report_diagnostic(checker, context);
} }
@ -378,7 +378,7 @@ impl Candidate {
fn report_diagnostic(self, checker: &Checker, context: Context) { fn report_diagnostic(self, checker: &Checker, context: Context) {
if !checker if !checker
.settings .settings()
.allowed_confusables .allowed_confusables
.contains(&self.confusable) .contains(&self.confusable)
{ {

2
crates/ruff_linter/src/rules/ruff/rules/function_call_in_dataclass_default.rs
View file

@ -107,7 +107,7 @@ pub(crate) fn function_call_in_dataclass_default(checker: &Checker, class_def: &
}; };
let extend_immutable_calls: Vec<QualifiedName> = checker let extend_immutable_calls: Vec<QualifiedName> = checker
.settings .settings()
.flake8_bugbear .flake8_bugbear
.extend_immutable_calls .extend_immutable_calls
.iter() .iter()

2
crates/ruff_linter/src/rules/ruff/rules/implicit_classvar_in_dataclass.rs
View file

@ -87,7 +87,7 @@ pub(crate) fn implicit_class_var_in_dataclass(checker: &mut Checker, class_def:
continue; continue;
}; };
if checker.settings.dummy_variable_rgx.is_match(id.as_str()) { if checker.settings().dummy_variable_rgx.is_match(id.as_str()) {
continue; continue;
} }

2
crates/ruff_linter/src/rules/ruff/rules/incorrectly_parenthesized_tuple_in_subscript.rs
View file

@ -63,7 +63,7 @@ impl AlwaysFixableViolation for IncorrectlyParenthesizedTupleInSubscript {
/// RUF031 /// RUF031
pub(crate) fn subscript_with_parenthesized_tuple(checker: &Checker, subscript: &ExprSubscript) { pub(crate) fn subscript_with_parenthesized_tuple(checker: &Checker, subscript: &ExprSubscript) {
let prefer_parentheses = checker.settings.ruff.parenthesize_tuple_in_subscript; let prefer_parentheses = checker.settings().ruff.parenthesize_tuple_in_subscript;
let Expr::Tuple(tuple_subscript) = &*subscript.slice else { let Expr::Tuple(tuple_subscript) = &*subscript.slice else {
return; return;

2
crates/ruff_linter/src/rules/ruff/rules/missing_fstring_syntax.rs
View file

@ -93,7 +93,7 @@ pub(crate) fn missing_fstring_syntax(checker: &Checker, literal: &ast::StringLit
} }
} }
let logger_objects = &checker.settings.logger_objects; let logger_objects = &checker.settings().logger_objects;
let fastapi_seen = semantic.seen_module(Modules::FASTAPI); let fastapi_seen = semantic.seen_module(Modules::FASTAPI);
// We also want to avoid: // We also want to avoid:

2
crates/ruff_linter/src/rules/ruff/rules/unused_unpacked_variable.rs
View file

@ -69,7 +69,7 @@ fn remove_unused_variable(binding: &Binding, checker: &Checker) -> Option<Fix> {
return None; return None;
} }
if checker.settings.dummy_variable_rgx.is_match(&renamed) { if checker.settings().dummy_variable_rgx.is_match(&renamed) {
let edit = Edit::range_replacement(renamed, binding.range()); let edit = Edit::range_replacement(renamed, binding.range());
return Some(Fix::unsafe_edit(edit).isolate(isolation)); return Some(Fix::unsafe_edit(edit).isolate(isolation));

4
crates/ruff_linter/src/rules/ruff/rules/used_dummy_variable.rs
View file

@ -157,7 +157,7 @@ pub(crate) fn used_dummy_variable(checker: &Checker, binding: &Binding, binding_
{ {
return; return;
} }
if !checker.settings.dummy_variable_rgx.is_match(name) { if !checker.settings().dummy_variable_rgx.is_match(name) {
return; return;
} }
@ -211,7 +211,7 @@ fn get_possible_new_name(
}; };
// Check if the fix name is again dummy identifier // Check if the fix name is again dummy identifier
if checker.settings.dummy_variable_rgx.is_match(&fix_name) { if checker.settings().dummy_variable_rgx.is_match(&fix_name) {
return None; return None;
} }

2
crates/ruff_linter/src/rules/tryceratops/rules/error_instead_of_exception.rs
View file

@ -73,7 +73,7 @@ pub(crate) fn error_instead_of_exception(checker: &Checker, handlers: &[ExceptHa
let ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler { body, .. }) = handler; let ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler { body, .. }) = handler;
let calls = { let calls = {
let mut visitor = let mut visitor =
LoggerCandidateVisitor::new(checker.semantic(), &checker.settings.logger_objects); LoggerCandidateVisitor::new(checker.semantic(), &checker.settings().logger_objects);
visitor.visit_body(body); visitor.visit_body(body);
visitor.calls visitor.calls
}; };

2
crates/ruff_linter/src/rules/tryceratops/rules/verbose_log_message.rs
View file

@ -51,7 +51,7 @@ pub(crate) fn verbose_log_message(checker: &Checker, handlers: &[ExceptHandler])
// Find all calls to `logging.exception`. // Find all calls to `logging.exception`.
let calls = { let calls = {
let mut visitor = let mut visitor =
LoggerCandidateVisitor::new(checker.semantic(), &checker.settings.logger_objects); LoggerCandidateVisitor::new(checker.semantic(), &checker.settings().logger_objects);
visitor.visit_body(body); visitor.visit_body(body);
visitor.calls visitor.calls
}; };