Implement B002 (unary prefix increment) (#468)

README.md

@@ -380,6 +380,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
+| B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
 | B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
 | B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
 | B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
@@ -472,7 +473,7 @@ including:
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (4/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (5/32)
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
 
@@ -492,7 +493,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (4/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (5/32)
 
 Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
 and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34).

resources/test/fixtures/B002.py

@@ -0,0 +1,20 @@
+"""
+Should emit:
+B002 - on lines 15 and 20
+"""
+
+
+def this_is_all_fine(n):
+    x = n + 1
+    y = 1 + n
+    z = +x + y
+    return +z
+
+
+def this_is_buggy(n):
+    x = ++n
+    return x
+
+
+def this_is_buggy_too(n):
+    return ++n

src/check_ast.rs

@@ -1131,6 +1131,10 @@ where
                         self,
                     ));
                 }
+
+                if self.settings.enabled.contains(&CheckCode::B002) {
+                    flake8_bugbear::plugins::unary_prefix_increment(self, expr, op, operand);
+                }
             }
             ExprKind::Compare {
                 left,

src/checks.rs

@@ -75,6 +75,7 @@ pub enum CheckCode {
     A002,
     A003,
     // flake8-bugbear
+    B002,
     B011,
     B014,
     B017,
@@ -266,6 +267,7 @@ pub enum CheckKind {
     BuiltinArgumentShadowing(String),
     BuiltinAttributeShadowing(String),
     // flake8-bugbear
+    UnaryPrefixIncrement,
     DoNotAssertFalse,
     DuplicateHandlerException(Vec<String>),
     NoAssertRaisesException,
@@ -426,6 +428,7 @@ impl CheckCode {
             CheckCode::A002 => CheckKind::BuiltinArgumentShadowing("...".to_string()),
             CheckCode::A003 => CheckKind::BuiltinAttributeShadowing("...".to_string()),
             // flake8-bugbear
+            CheckCode::B002 => CheckKind::UnaryPrefixIncrement,
             CheckCode::B011 => CheckKind::DoNotAssertFalse,
             CheckCode::B014 => CheckKind::DuplicateHandlerException(vec!["ValueError".to_string()]),
             CheckCode::B017 => CheckKind::NoAssertRaisesException,
@@ -601,6 +604,7 @@ impl CheckCode {
             CheckCode::A001 => CheckCategory::Flake8Builtins,
             CheckCode::A002 => CheckCategory::Flake8Builtins,
             CheckCode::A003 => CheckCategory::Flake8Builtins,
+            CheckCode::B002 => CheckCategory::Flake8Bugbear,
             CheckCode::B011 => CheckCategory::Flake8Bugbear,
             CheckCode::B014 => CheckCategory::Flake8Bugbear,
             CheckCode::B017 => CheckCategory::Flake8Bugbear,
@@ -745,6 +749,7 @@ impl CheckKind {
             CheckKind::BuiltinArgumentShadowing(_) => &CheckCode::A002,
             CheckKind::BuiltinAttributeShadowing(_) => &CheckCode::A003,
             // flake8-bugbear
+            CheckKind::UnaryPrefixIncrement => &CheckCode::B002,
             CheckKind::DoNotAssertFalse => &CheckCode::B011,
             CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
@@ -984,6 +989,7 @@ impl CheckKind {
                 format!("Class attribute `{name}` is shadowing a python builtin")
             }
             // flake8-bugbear
+            CheckKind::UnaryPrefixIncrement => "Python does not support the unary prefix increment. Writing `++n` is equivalent to `+(+(n))`, which equals `n`. You meant `n += 1`.".to_string(),
             CheckKind::DoNotAssertFalse => {
                 "Do not `assert False` (`python -O` removes these calls), raise `AssertionError()`"
                     .to_string()
@@ -1266,9 +1272,12 @@ impl CheckKind {
         }
     }
 
-    /// The summary text for the check.
+    /// The summary text for the check. Typically a truncated form of the body text.
     pub fn summary(&self) -> String {
         match self {
+            CheckKind::UnaryPrefixIncrement => {
+                "Python does not support the unary prefix increment.".to_string()
+            }
             CheckKind::NoAssertRaisesException => {
                 "`assertRaises(Exception):` should be considered evil.".to_string()
             }

src/flake8_bugbear/plugins/mod.rs

@@ -2,7 +2,9 @@ pub use assert_false::assert_false;
 pub use assert_raises_exception::assert_raises_exception;
 pub use duplicate_exceptions::duplicate_exceptions;
 pub use duplicate_exceptions::duplicate_handler_exceptions;
+pub use unary_prefix_increment::unary_prefix_increment;
 
 mod assert_false;
 mod assert_raises_exception;
 mod duplicate_exceptions;
+mod unary_prefix_increment;

src/flake8_bugbear/plugins/unary_prefix_increment.rs

@@ -0,0 +1,19 @@
+use rustpython_ast::{Expr, ExprKind, Unaryop};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B002
+pub fn unary_prefix_increment(checker: &mut Checker, expr: &Expr, op: &Unaryop, operand: &Expr) {
+    if matches!(op, Unaryop::UAdd) {
+        if let ExprKind::UnaryOp { op, .. } = &operand.node {
+            if matches!(op, Unaryop::UAdd) {
+                checker.add_check(Check::new(
+                    CheckKind::UnaryPrefixIncrement,
+                    Range::from_located(expr),
+                ))
+            }
+        }
+    }
+}

src/linter.rs

@@ -245,6 +245,7 @@ mod tests {
     #[test_case(CheckCode::A001, Path::new("A001.py"); "A001")]
     #[test_case(CheckCode::A002, Path::new("A002.py"); "A002")]
     #[test_case(CheckCode::A003, Path::new("A003.py"); "A003")]
+    #[test_case(CheckCode::B002, Path::new("B002.py"); "B002")]
     #[test_case(CheckCode::B011, Path::new("B011.py"); "B011")]
     #[test_case(CheckCode::B014, Path::new("B014.py"); "B014")]
     #[test_case(CheckCode::B017, Path::new("B017.py"); "B017")]

src/snapshots/ruff__linter__tests__B002_B002.py.snap

@@ -0,0 +1,21 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: UnaryPrefixIncrement
+  location:
+    row: 15
+    column: 9
+  end_location:
+    row: 15
+    column: 12
+  fix: ~
+- kind: UnaryPrefixIncrement
+  location:
+    row: 20
+    column: 12
+  end_location:
+    row: 20
+    column: 15
+  fix: ~
+