diff --git a/crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE790.py b/crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE790.py index 976b15dbd52ef..4f0ec323e5930 100644 --- a/crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE790.py +++ b/crates/ruff_linter/resources/test/fixtures/flake8_pie/PIE790.py @@ -148,3 +148,32 @@ def foo(): for i in range(10): pass # comment pass + + +def foo(): + print("foo") + ... + + +def foo(): + """A docstring.""" + print("foo") + ... + + +for i in range(10): + ... + ... + +for i in range(10): + ... + + ... + +for i in range(10): + ... # comment + ... + +for i in range(10): + ... + pass diff --git a/crates/ruff_linter/src/checkers/ast/analyze/suite.rs b/crates/ruff_linter/src/checkers/ast/analyze/suite.rs index 002635eac9919..3cad1b3a1e730 100644 --- a/crates/ruff_linter/src/checkers/ast/analyze/suite.rs +++ b/crates/ruff_linter/src/checkers/ast/analyze/suite.rs @@ -6,7 +6,7 @@ use crate::rules::flake8_pie; /// Run lint rules over a suite of [`Stmt`] syntax nodes. pub(crate) fn suite(suite: &[Stmt], checker: &mut Checker) { - if checker.enabled(Rule::UnnecessaryPass) { - flake8_pie::rules::no_unnecessary_pass(checker, suite); + if checker.enabled(Rule::UnnecessaryPlaceholder) { + flake8_pie::rules::unnecessary_placeholder(checker, suite); } } diff --git a/crates/ruff_linter/src/codes.rs b/crates/ruff_linter/src/codes.rs index 47b382eae4f76..8efb7b5e2c460 100644 --- a/crates/ruff_linter/src/codes.rs +++ b/crates/ruff_linter/src/codes.rs @@ -768,7 +768,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> { (Flake8PytestStyle, "027") => (RuleGroup::Stable, rules::flake8_pytest_style::rules::PytestUnittestRaisesAssertion), // flake8-pie - (Flake8Pie, "790") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessaryPass), + (Flake8Pie, "790") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessaryPlaceholder), (Flake8Pie, "794") => (RuleGroup::Stable, rules::flake8_pie::rules::DuplicateClassFieldDefinition), (Flake8Pie, "796") => (RuleGroup::Stable, rules::flake8_pie::rules::NonUniqueEnums), (Flake8Pie, "800") => (RuleGroup::Stable, rules::flake8_pie::rules::UnnecessarySpread), diff --git a/crates/ruff_linter/src/rules/flake8_pie/mod.rs b/crates/ruff_linter/src/rules/flake8_pie/mod.rs index be3a2ce2770d6..3cf692c3625c3 100644 --- a/crates/ruff_linter/src/rules/flake8_pie/mod.rs +++ b/crates/ruff_linter/src/rules/flake8_pie/mod.rs @@ -17,7 +17,7 @@ mod tests { #[test_case(Rule::UnnecessaryDictKwargs, Path::new("PIE804.py"))] #[test_case(Rule::MultipleStartsEndsWith, Path::new("PIE810.py"))] #[test_case(Rule::UnnecessaryRangeStart, Path::new("PIE808.py"))] - #[test_case(Rule::UnnecessaryPass, Path::new("PIE790.py"))] + #[test_case(Rule::UnnecessaryPlaceholder, Path::new("PIE790.py"))] #[test_case(Rule::UnnecessarySpread, Path::new("PIE800.py"))] #[test_case(Rule::ReimplementedContainerBuiltin, Path::new("PIE807.py"))] #[test_case(Rule::NonUniqueEnums, Path::new("PIE796.py"))] @@ -31,6 +31,7 @@ mod tests { Ok(()) } + #[test_case(Rule::UnnecessaryPlaceholder, Path::new("PIE790.py"))] #[test_case(Rule::ReimplementedContainerBuiltin, Path::new("PIE807.py"))] fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> { let snapshot = format!( diff --git a/crates/ruff_linter/src/rules/flake8_pie/rules/mod.rs b/crates/ruff_linter/src/rules/flake8_pie/rules/mod.rs index a02d706b64e50..0ca5f36a90273 100644 --- a/crates/ruff_linter/src/rules/flake8_pie/rules/mod.rs +++ b/crates/ruff_linter/src/rules/flake8_pie/rules/mod.rs @@ -3,7 +3,7 @@ pub(crate) use multiple_starts_ends_with::*; pub(crate) use non_unique_enums::*; pub(crate) use reimplemented_container_builtin::*; pub(crate) use unnecessary_dict_kwargs::*; -pub(crate) use unnecessary_pass::*; +pub(crate) use unnecessary_placeholder::*; pub(crate) use unnecessary_range_start::*; pub(crate) use unnecessary_spread::*; @@ -12,6 +12,6 @@ mod multiple_starts_ends_with; mod non_unique_enums; mod reimplemented_container_builtin; mod unnecessary_dict_kwargs; -mod unnecessary_pass; +mod unnecessary_placeholder; mod unnecessary_range_start; mod unnecessary_spread; diff --git a/crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_pass.rs b/crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_pass.rs deleted file mode 100644 index fe845646a2c35..0000000000000 --- a/crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_pass.rs +++ /dev/null @@ -1,75 +0,0 @@ -use ruff_python_ast::Stmt; - -use ruff_diagnostics::AlwaysFixableViolation; -use ruff_diagnostics::{Diagnostic, Edit, Fix}; -use ruff_macros::{derive_message_formats, violation}; -use ruff_python_ast::whitespace::trailing_comment_start_offset; -use ruff_text_size::Ranged; - -use crate::checkers::ast::Checker; -use crate::fix; - -/// ## What it does -/// Checks for unnecessary `pass` statements in functions, classes, and other -/// blocks. -/// -/// ## Why is this bad? -/// In Python, the `pass` statement serves as a placeholder, allowing for -/// syntactically correct empty code blocks. The primary purpose of the `pass` -/// statement is to avoid syntax errors in situations where a statement is -/// syntactically required, but no code needs to be executed. -/// -/// If a `pass` statement is present in a code block that includes at least -/// one other statement (even, e.g., a docstring), it is unnecessary and should -/// be removed. -/// -/// ## Example -/// ```python -/// def func(): -/// """Placeholder docstring.""" -/// pass -/// ``` -/// -/// Use instead: -/// ```python -/// def func(): -/// """Placeholder docstring.""" -/// ``` -/// -/// ## References -/// - [Python documentation: The `pass` statement](https://docs.python.org/3/reference/simple_stmts.html#the-pass-statement) -#[violation] -pub struct UnnecessaryPass; - -impl AlwaysFixableViolation for UnnecessaryPass { - #[derive_message_formats] - fn message(&self) -> String { - format!("Unnecessary `pass` statement") - } - - fn fix_title(&self) -> String { - "Remove unnecessary `pass`".to_string() - } -} - -/// PIE790 -pub(crate) fn no_unnecessary_pass(checker: &mut Checker, body: &[Stmt]) { - if body.len() < 2 { - return; - } - - body.iter() - .filter(|stmt| stmt.is_pass_stmt()) - .for_each(|stmt| { - let mut diagnostic = Diagnostic::new(UnnecessaryPass, stmt.range()); - let edit = if let Some(index) = trailing_comment_start_offset(stmt, checker.locator()) { - Edit::range_deletion(stmt.range().add_end(index)) - } else { - fix::edits::delete_stmt(stmt, None, checker.locator(), checker.indexer()) - }; - diagnostic.set_fix(Fix::safe_edit(edit).isolate(Checker::isolation( - checker.semantic().current_statement_id(), - ))); - checker.diagnostics.push(diagnostic); - }); -} diff --git a/crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_placeholder.rs b/crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_placeholder.rs new file mode 100644 index 0000000000000..918ed7eb111d2 --- /dev/null +++ b/crates/ruff_linter/src/rules/flake8_pie/rules/unnecessary_placeholder.rs @@ -0,0 +1,127 @@ +use ruff_diagnostics::AlwaysFixableViolation; +use ruff_diagnostics::{Diagnostic, Edit, Fix}; +use ruff_macros::{derive_message_formats, violation}; +use ruff_python_ast::whitespace::trailing_comment_start_offset; +use ruff_python_ast::Stmt; +use ruff_text_size::Ranged; + +use crate::checkers::ast::Checker; +use crate::fix; + +/// ## What it does +/// Checks for unnecessary `pass` statements in functions, classes, and other +/// blocks. +/// +/// In [preview], this rule also checks for unnecessary ellipsis (`...`) +/// literals. +/// +/// ## Why is this bad? +/// In Python, the `pass` statement and ellipsis (`...`) literal serve as +/// placeholders, allowing for syntactically correct empty code blocks. The +/// primary purpose of these nodes is to avoid syntax errors in situations +/// where a statement or expression is syntactically required, but no code +/// needs to be executed. +/// +/// If a `pass` or ellipsis is present in a code block that includes at least +/// one other statement (even, e.g., a docstring), it is unnecessary and should +/// be removed. +/// +/// ## Example +/// ```python +/// def func(): +/// """Placeholder docstring.""" +/// pass +/// ``` +/// +/// Use instead: +/// ```python +/// def func(): +/// """Placeholder docstring.""" +/// ``` +/// +/// In [preview]: +/// ```python +/// def func(): +/// """Placeholder docstring.""" +/// ... +/// ``` +/// +/// Use instead: +/// ```python +/// def func(): +/// """Placeholder docstring.""" +/// ``` +/// +/// ## References +/// - [Python documentation: The `pass` statement](https://docs.python.org/3/reference/simple_stmts.html#the-pass-statement) +/// +/// [preview]: https://docs.astral.sh/ruff/preview/ +#[violation] +pub struct UnnecessaryPlaceholder { + kind: Placeholder, +} + +impl AlwaysFixableViolation for UnnecessaryPlaceholder { + #[derive_message_formats] + fn message(&self) -> String { + let Self { kind } = self; + match kind { + Placeholder::Pass => format!("Unnecessary `pass` statement"), + Placeholder::Ellipsis => format!("Unnecessary `...` literal"), + } + } + + fn fix_title(&self) -> String { + let Self { kind } = self; + match kind { + Placeholder::Pass => format!("Remove unnecessary `pass`"), + Placeholder::Ellipsis => format!("Remove unnecessary `...`"), + } + } +} + +/// PIE790 +pub(crate) fn unnecessary_placeholder(checker: &mut Checker, body: &[Stmt]) { + if body.len() < 2 { + return; + } + + for stmt in body { + let kind = match stmt { + Stmt::Pass(_) => Placeholder::Pass, + Stmt::Expr(expr) + if expr.value.is_ellipsis_literal_expr() + && checker.settings.preview.is_enabled() => + { + Placeholder::Ellipsis + } + _ => continue, + }; + + let mut diagnostic = Diagnostic::new(UnnecessaryPlaceholder { kind }, stmt.range()); + let edit = if let Some(index) = trailing_comment_start_offset(stmt, checker.locator()) { + Edit::range_deletion(stmt.range().add_end(index)) + } else { + fix::edits::delete_stmt(stmt, None, checker.locator(), checker.indexer()) + }; + diagnostic.set_fix(Fix::safe_edit(edit).isolate(Checker::isolation( + checker.semantic().current_statement_id(), + ))); + checker.diagnostics.push(diagnostic); + } +} + +#[derive(Debug, PartialEq, Eq)] +enum Placeholder { + Pass, + Ellipsis, +} + +impl std::fmt::Display for Placeholder { + fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Pass => fmt.write_str("pass"), + Self::Ellipsis => fmt.write_str("..."), + } + } +} diff --git a/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__PIE790_PIE790.py.snap b/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__PIE790_PIE790.py.snap index 2b498cc75ca2c..51ba3433d9e4f 100644 --- a/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__PIE790_PIE790.py.snap +++ b/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__PIE790_PIE790.py.snap @@ -446,6 +446,8 @@ PIE790.py:149:5: PIE790 [*] Unnecessary `pass` statement 149 |- pass # comment 149 |+ # comment 150 150 | pass +151 151 | +152 152 | PIE790.py:150:5: PIE790 [*] Unnecessary `pass` statement | @@ -461,5 +463,23 @@ PIE790.py:150:5: PIE790 [*] Unnecessary `pass` statement 148 148 | for i in range(10): 149 149 | pass # comment 150 |- pass +151 150 | +152 151 | +153 152 | def foo(): + +PIE790.py:179:5: PIE790 [*] Unnecessary `pass` statement + | +177 | for i in range(10): +178 | ... +179 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +176 176 | +177 177 | for i in range(10): +178 178 | ... +179 |- pass diff --git a/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__preview__PIE790_PIE790.py.snap b/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__preview__PIE790_PIE790.py.snap new file mode 100644 index 0000000000000..045fbbb955722 --- /dev/null +++ b/crates/ruff_linter/src/rules/flake8_pie/snapshots/ruff_linter__rules__flake8_pie__tests__preview__PIE790_PIE790.py.snap @@ -0,0 +1,653 @@ +--- +source: crates/ruff_linter/src/rules/flake8_pie/mod.rs +--- +PIE790.py:4:5: PIE790 [*] Unnecessary `pass` statement + | +2 | """buzz""" +3 | +4 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +1 1 | class Foo: +2 2 | """buzz""" +3 3 | +4 |- pass +5 4 | +6 5 | +7 6 | if foo: + +PIE790.py:9:5: PIE790 [*] Unnecessary `pass` statement + | +7 | if foo: +8 | """foo""" +9 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +6 6 | +7 7 | if foo: +8 8 | """foo""" +9 |- pass +10 9 | +11 10 | +12 11 | def multi_statement() -> None: + +PIE790.py:14:5: PIE790 [*] Unnecessary `pass` statement + | +12 | def multi_statement() -> None: +13 | """This is a function.""" +14 | pass; print("hello") + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +11 11 | +12 12 | def multi_statement() -> None: +13 13 | """This is a function.""" +14 |- pass; print("hello") + 14 |+ print("hello") +15 15 | +16 16 | +17 17 | if foo: + +PIE790.py:21:5: PIE790 [*] Unnecessary `pass` statement + | +19 | else: +20 | """bar""" +21 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +18 18 | pass +19 19 | else: +20 20 | """bar""" +21 |- pass +22 21 | +23 22 | +24 23 | while True: + +PIE790.py:28:5: PIE790 [*] Unnecessary `pass` statement + | +26 | else: +27 | """bar""" +28 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +25 25 | pass +26 26 | else: +27 27 | """bar""" +28 |- pass +29 28 | +30 29 | +31 30 | for _ in range(10): + +PIE790.py:35:5: PIE790 [*] Unnecessary `pass` statement + | +33 | else: +34 | """bar""" +35 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +32 32 | pass +33 33 | else: +34 34 | """bar""" +35 |- pass +36 35 | +37 36 | +38 37 | async for _ in range(10): + +PIE790.py:42:5: PIE790 [*] Unnecessary `pass` statement + | +40 | else: +41 | """bar""" +42 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +39 39 | pass +40 40 | else: +41 41 | """bar""" +42 |- pass +43 42 | +44 43 | +45 44 | def foo() -> None: + +PIE790.py:50:5: PIE790 [*] Unnecessary `pass` statement + | +48 | """ +49 | +50 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +47 47 | buzz +48 48 | """ +49 49 | +50 |- pass +51 50 | +52 51 | +53 52 | async def foo(): + +PIE790.py:58:5: PIE790 [*] Unnecessary `pass` statement + | +56 | """ +57 | +58 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +55 55 | buzz +56 56 | """ +57 57 | +58 |- pass +59 58 | +60 59 | +61 60 | try: + +PIE790.py:65:5: PIE790 [*] Unnecessary `pass` statement + | +63 | buzz +64 | """ +65 | pass + | ^^^^ PIE790 +66 | except ValueError: +67 | pass + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +62 62 | """ +63 63 | buzz +64 64 | """ +65 |- pass +66 65 | except ValueError: +67 66 | pass +68 67 | + +PIE790.py:74:5: PIE790 [*] Unnecessary `pass` statement + | +72 | except ValueError: +73 | """bar""" +74 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +71 71 | bar() +72 72 | except ValueError: +73 73 | """bar""" +74 |- pass +75 74 | +76 75 | +77 76 | for _ in range(10): + +PIE790.py:79:5: PIE790 [*] Unnecessary `pass` statement + | +77 | for _ in range(10): +78 | """buzz""" +79 | pass + | ^^^^ PIE790 +80 | +81 | async for _ in range(10): + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +76 76 | +77 77 | for _ in range(10): +78 78 | """buzz""" +79 |- pass +80 79 | +81 80 | async for _ in range(10): +82 81 | """buzz""" + +PIE790.py:83:5: PIE790 [*] Unnecessary `pass` statement + | +81 | async for _ in range(10): +82 | """buzz""" +83 | pass + | ^^^^ PIE790 +84 | +85 | while cond: + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +80 80 | +81 81 | async for _ in range(10): +82 82 | """buzz""" +83 |- pass +84 83 | +85 84 | while cond: +86 85 | """buzz""" + +PIE790.py:87:5: PIE790 [*] Unnecessary `pass` statement + | +85 | while cond: +86 | """buzz""" +87 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +84 84 | +85 85 | while cond: +86 86 | """buzz""" +87 |- pass +88 87 | +89 88 | +90 89 | with bar: + +PIE790.py:92:5: PIE790 [*] Unnecessary `pass` statement + | +90 | with bar: +91 | """buzz""" +92 | pass + | ^^^^ PIE790 +93 | +94 | async with bar: + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +89 89 | +90 90 | with bar: +91 91 | """buzz""" +92 |- pass +93 92 | +94 93 | async with bar: +95 94 | """buzz""" + +PIE790.py:96:5: PIE790 [*] Unnecessary `pass` statement + | +94 | async with bar: +95 | """buzz""" +96 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +93 93 | +94 94 | async with bar: +95 95 | """buzz""" +96 |- pass +97 96 | +98 97 | +99 98 | def foo() -> None: + +PIE790.py:101:5: PIE790 [*] Unnecessary `pass` statement + | + 99 | def foo() -> None: +100 | """buzz""" +101 | pass # bar + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +98 98 | +99 99 | def foo() -> None: +100 100 | """buzz""" +101 |- pass # bar + 101 |+ # bar +102 102 | +103 103 | +104 104 | class Foo: + +PIE790.py:130:5: PIE790 [*] Unnecessary `pass` statement + | +128 | def foo(): +129 | print("foo") +130 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +127 127 | +128 128 | def foo(): +129 129 | print("foo") +130 |- pass +131 130 | +132 131 | +133 132 | def foo(): + +PIE790.py:136:5: PIE790 [*] Unnecessary `pass` statement + | +134 | """A docstring.""" +135 | print("foo") +136 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +133 133 | def foo(): +134 134 | """A docstring.""" +135 135 | print("foo") +136 |- pass +137 136 | +138 137 | +139 138 | for i in range(10): + +PIE790.py:140:5: PIE790 [*] Unnecessary `pass` statement + | +139 | for i in range(10): +140 | pass + | ^^^^ PIE790 +141 | pass + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +138 138 | +139 139 | for i in range(10): +140 140 | pass +141 |- pass +142 141 | +143 142 | for i in range(10): +144 143 | pass + +PIE790.py:141:5: PIE790 [*] Unnecessary `pass` statement + | +139 | for i in range(10): +140 | pass +141 | pass + | ^^^^ PIE790 +142 | +143 | for i in range(10): + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +138 138 | +139 139 | for i in range(10): +140 140 | pass +141 |- pass +142 141 | +143 142 | for i in range(10): +144 143 | pass + +PIE790.py:144:5: PIE790 [*] Unnecessary `pass` statement + | +143 | for i in range(10): +144 | pass + | ^^^^ PIE790 +145 | +146 | pass + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +141 141 | pass +142 142 | +143 143 | for i in range(10): +144 |- pass +145 144 | +146 145 | pass +147 146 | + +PIE790.py:146:5: PIE790 [*] Unnecessary `pass` statement + | +144 | pass +145 | +146 | pass + | ^^^^ PIE790 +147 | +148 | for i in range(10): + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +143 143 | for i in range(10): +144 144 | pass +145 145 | +146 |- pass +147 146 | +148 147 | for i in range(10): +149 148 | pass # comment + +PIE790.py:149:5: PIE790 [*] Unnecessary `pass` statement + | +148 | for i in range(10): +149 | pass # comment + | ^^^^ PIE790 +150 | pass + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +146 146 | pass +147 147 | +148 148 | for i in range(10): +149 |- pass # comment + 149 |+ # comment +150 150 | pass +151 151 | +152 152 | + +PIE790.py:150:5: PIE790 [*] Unnecessary `pass` statement + | +148 | for i in range(10): +149 | pass # comment +150 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +147 147 | +148 148 | for i in range(10): +149 149 | pass # comment +150 |- pass +151 150 | +152 151 | +153 152 | def foo(): + +PIE790.py:155:5: PIE790 [*] Unnecessary `...` literal + | +153 | def foo(): +154 | print("foo") +155 | ... + | ^^^ PIE790 + | + = help: Remove unnecessary `...` + +ℹ Safe fix +152 152 | +153 153 | def foo(): +154 154 | print("foo") +155 |- ... +156 155 | +157 156 | +158 157 | def foo(): + +PIE790.py:161:5: PIE790 [*] Unnecessary `...` literal + | +159 | """A docstring.""" +160 | print("foo") +161 | ... + | ^^^ PIE790 + | + = help: Remove unnecessary `...` + +ℹ Safe fix +158 158 | def foo(): +159 159 | """A docstring.""" +160 160 | print("foo") +161 |- ... +162 161 | +163 162 | +164 163 | for i in range(10): + +PIE790.py:165:5: PIE790 [*] Unnecessary `...` literal + | +164 | for i in range(10): +165 | ... + | ^^^ PIE790 +166 | ... + | + = help: Remove unnecessary `...` + +ℹ Safe fix +163 163 | +164 164 | for i in range(10): +165 165 | ... +166 |- ... +167 166 | +168 167 | for i in range(10): +169 168 | ... + +PIE790.py:166:5: PIE790 [*] Unnecessary `...` literal + | +164 | for i in range(10): +165 | ... +166 | ... + | ^^^ PIE790 +167 | +168 | for i in range(10): + | + = help: Remove unnecessary `...` + +ℹ Safe fix +163 163 | +164 164 | for i in range(10): +165 165 | ... +166 |- ... +167 166 | +168 167 | for i in range(10): +169 168 | ... + +PIE790.py:169:5: PIE790 [*] Unnecessary `...` literal + | +168 | for i in range(10): +169 | ... + | ^^^ PIE790 +170 | +171 | ... + | + = help: Remove unnecessary `...` + +ℹ Safe fix +166 166 | ... +167 167 | +168 168 | for i in range(10): +169 |- ... +170 169 | +171 170 | ... +172 171 | + +PIE790.py:171:5: PIE790 [*] Unnecessary `...` literal + | +169 | ... +170 | +171 | ... + | ^^^ PIE790 +172 | +173 | for i in range(10): + | + = help: Remove unnecessary `...` + +ℹ Safe fix +168 168 | for i in range(10): +169 169 | ... +170 170 | +171 |- ... +172 171 | +173 172 | for i in range(10): +174 173 | ... # comment + +PIE790.py:174:5: PIE790 [*] Unnecessary `...` literal + | +173 | for i in range(10): +174 | ... # comment + | ^^^ PIE790 +175 | ... + | + = help: Remove unnecessary `...` + +ℹ Safe fix +171 171 | ... +172 172 | +173 173 | for i in range(10): +174 |- ... # comment + 174 |+ # comment +175 175 | ... +176 176 | +177 177 | for i in range(10): + +PIE790.py:175:5: PIE790 [*] Unnecessary `...` literal + | +173 | for i in range(10): +174 | ... # comment +175 | ... + | ^^^ PIE790 +176 | +177 | for i in range(10): + | + = help: Remove unnecessary `...` + +ℹ Safe fix +172 172 | +173 173 | for i in range(10): +174 174 | ... # comment +175 |- ... +176 175 | +177 176 | for i in range(10): +178 177 | ... + +PIE790.py:178:5: PIE790 [*] Unnecessary `...` literal + | +177 | for i in range(10): +178 | ... + | ^^^ PIE790 +179 | pass + | + = help: Remove unnecessary `...` + +ℹ Safe fix +175 175 | ... +176 176 | +177 177 | for i in range(10): +178 |- ... +179 178 | pass + +PIE790.py:179:5: PIE790 [*] Unnecessary `pass` statement + | +177 | for i in range(10): +178 | ... +179 | pass + | ^^^^ PIE790 + | + = help: Remove unnecessary `pass` + +ℹ Safe fix +176 176 | +177 177 | for i in range(10): +178 178 | ... +179 |- pass + +