Expand the scope of useless-expression (B018)

crates/ruff/src/checkers/ast/mod.rs

@@ -420,10 +420,6 @@ where
                     pyupgrade::rules::functools_cache(self, decorator_list);
                 }
 
-                if self.settings.rules.enabled(&Rule::UselessExpression) {
-                    flake8_bugbear::rules::useless_expression(self, body);
-                }
-
                 if self.settings.rules.enabled(&Rule::CachedInstanceMethod) {
                     flake8_bugbear::rules::cached_instance_method(self, decorator_list);
                 }
@@ -756,10 +752,6 @@ where
                     }
                 }
 
-                if self.settings.rules.enabled(&Rule::UselessExpression) {
-                    flake8_bugbear::rules::useless_expression(self, body);
-                }
-
                 if !self.is_stub {
                     if self
                         .settings
@@ -1886,6 +1878,9 @@ where
                 if self.settings.rules.enabled(&Rule::UselessComparison) {
                     flake8_bugbear::rules::useless_comparison(self, value);
                 }
+                if self.settings.rules.enabled(&Rule::UselessExpression) {
+                    flake8_bugbear::rules::useless_expression(self, value);
+                }
                 if self
                     .settings
                     .rules

crates/ruff/src/rules/flake8_bugbear/rules/useless_expression.rs

@@ -1,7 +1,8 @@
-use rustpython_parser::ast::{Constant, ExprKind, Stmt, StmtKind};
+use rustpython_parser::ast::{Constant, Expr, ExprKind};
 
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::helpers::contains_effect;
 use ruff_python_ast::types::Range;
 
 use crate::checkers::ast::Checker;
@@ -17,25 +18,25 @@ impl Violation for UselessExpression {
 }
 
 /// B018
-pub fn useless_expression(checker: &mut Checker, body: &[Stmt]) {
-    for stmt in body {
-        if let StmtKind::Expr { value } = &stmt.node {
-            match &value.node {
-                ExprKind::List { .. } | ExprKind::Dict { .. } | ExprKind::Set { .. } => {
-                    checker
-                        .diagnostics
-                        .push(Diagnostic::new(UselessExpression, Range::from(value)));
-                }
-                ExprKind::Constant { value: val, .. } => match &val {
-                    Constant::Str { .. } | Constant::Ellipsis => {}
-                    _ => {
-                        checker
-                            .diagnostics
-                            .push(Diagnostic::new(UselessExpression, Range::from(value)));
-                    }
-                },
-                _ => {}
+pub fn useless_expression(checker: &mut Checker, value: &Expr) {
+    // Ignore strings, to avoid false positives with docstrings.
+    if matches!(
+        value.node,
+        ExprKind::JoinedStr { .. }
+            | ExprKind::Constant {
+                value: Constant::Str(..) | Constant::Ellipsis,
+                ..
             }
-        }
+    ) {
+        return;
     }
+
+    // Ignore statements that have side effects.
+    if contains_effect(&checker.ctx, value) {
+        return;
+    }
+
+    checker
+        .diagnostics
+        .push(Diagnostic::new(UselessExpression, Range::from(value)));
 }

crates/ruff_python_ast/src/helpers.rs

@@ -8,7 +8,7 @@ use regex::Regex;
 use rustc_hash::{FxHashMap, FxHashSet};
 use rustpython_parser::ast::{
     Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Keyword, KeywordData,
-    Located, Location, MatchCase, Pattern, PatternKind, Stmt, StmtKind,
+    Located, Location, MatchCase, Operator, Pattern, PatternKind, Stmt, StmtKind,
 };
 use rustpython_parser::{lexer, Mode, StringKind, Tok};
 use smallvec::{smallvec, SmallVec};
@@ -142,6 +142,11 @@ pub fn contains_effect(ctx: &Context, expr: &Expr) -> bool {
                 | ExprKind::Subscript { .. }
                 | ExprKind::Yield { .. }
                 | ExprKind::YieldFrom { .. }
+                | ExprKind::BinOp {
+                    // These are often used as side-effects, e.g., `foo >> bar`.
+                    op: Operator::LShift | Operator::RShift,
+                    ..
+                }
         )
     })
 }