SIM300: CONSTANT_CASE variables are improperly flagged for yoda viola…

…tion (#9164)

## Summary

fixes #6956 
details in issue

Following an advice in
#6956 (comment),
this change separates expressions to 3 levels of "constant likelihood":
*  literals, empty dict and tuples... (definitely constant, level 2)
*  CONSTANT_CASE vars (probably constant, 1)
* all other expressions (0)

a comparison is marked yoda if the level is strictly higher on its left
hand side

following
#6956 (comment)
marking compound expressions of literals (e.g. `60 * 60` ) as constants
this change current behaviour on
`SomeClass().settings.SOME_CONSTANT_VALUE > (60 * 60)` in the fixture
from error to ok

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM300.py

@@ -1,6 +1,5 @@
 # Errors
 "yoda" == compare  # SIM300
-"yoda" == compare  # SIM300
 42 == age  # SIM300
 ("a", "b") == compare  # SIM300
 "yoda" <= compare  # SIM300
@@ -13,10 +12,17 @@
 YODA >= age  # SIM300
 JediOrder.YODA == age  # SIM300
 0 < (number - 100)  # SIM300
-SomeClass().settings.SOME_CONSTANT_VALUE > (60 * 60)  # SIM300
 B<A[0][0]or B
 B or(B)<A[0][0]
 
+# Errors in preview
+['upper'] == UPPER_LIST
+{} == DummyHandler.CONFIG
+
+# Errors in stable
+UPPER_LIST == ['upper']
+DummyHandler.CONFIG == {}
+
 # OK
 compare == "yoda"
 age == 42
@@ -31,3 +37,6 @@
 YODA == YODA
 age == JediOrder.YODA
 (number - 100) > 0
+SECONDS_IN_DAY == 60 * 60 * 24 # Error in 0.1.8
+SomeClass().settings.SOME_CONSTANT_VALUE > (60 * 60) # Error in 0.1.8
+{"non-empty-dict": "is-ok"} == DummyHandler.CONFIG

crates/ruff_linter/src/rules/flake8_simplify/mod.rs

@@ -56,6 +56,7 @@ mod tests {
     }
 
     #[test_case(Rule::InDictKeys, Path::new("SIM118.py"))]
+    #[test_case(Rule::YodaConditions, Path::new("SIM300.py"))]
     #[test_case(Rule::IfElseBlockInsteadOfDictGet, Path::new("SIM401.py"))]
     #[test_case(Rule::DictGetWithNoneDefault, Path::new("SIM910.py"))]
     fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> {

crates/ruff_linter/src/rules/flake8_simplify/rules/yoda_conditions.rs

@@ -1,3 +1,5 @@
+use std::cmp;
+
 use anyhow::Result;
 use libcst_native::CompOp;
 
@@ -14,6 +16,7 @@ use crate::cst::helpers::or_space;
 use crate::cst::matchers::{match_comparison, transform_expression};
 use crate::fix::edits::pad;
 use crate::fix::snippet::SourceCodeSnippet;
+use crate::settings::types::PreviewMode;
 
 /// ## What it does
 /// Checks for conditions that position a constant on the left-hand side of the
@@ -78,18 +81,65 @@ impl Violation for YodaConditions {
     }
 }
 
-/// Return `true` if an [`Expr`] is a constant or a constant-like name.
-fn is_constant_like(expr: &Expr) -> bool {
-    match expr {
-        Expr::Attribute(ast::ExprAttribute { attr, .. }) => str::is_cased_uppercase(attr),
-        Expr::Tuple(ast::ExprTuple { elts, .. }) => elts.iter().all(is_constant_like),
-        Expr::Name(ast::ExprName { id, .. }) => str::is_cased_uppercase(id),
-        Expr::UnaryOp(ast::ExprUnaryOp {
-            op: UnaryOp::UAdd | UnaryOp::USub | UnaryOp::Invert,
-            operand,
-            range: _,
-        }) => operand.is_literal_expr(),
-        _ => expr.is_literal_expr(),
+/// Comparisons left-hand side must not be more [`ConstantLikelihood`] than the right-hand side.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
+enum ConstantLikelihood {
+    /// The expression is unlikely to be a constant (e.g., `foo` or `foo(bar)`).
+    Unlikely = 0,
+
+    /// The expression is likely to be a constant (e.g., `FOO`).
+    Probably = 1,
+
+    /// The expression is definitely a constant (e.g., `42` or `"foo"`).
+    Definitely = 2,
+}
+
+impl ConstantLikelihood {
+    /// Determine the [`ConstantLikelihood`] of an expression.
+    fn from_expression(expr: &Expr, preview: PreviewMode) -> Self {
+        match expr {
+            _ if expr.is_literal_expr() => ConstantLikelihood::Definitely,
+            Expr::Attribute(ast::ExprAttribute { attr, .. }) => {
+                ConstantLikelihood::from_identifier(attr)
+            }
+            Expr::Name(ast::ExprName { id, .. }) => ConstantLikelihood::from_identifier(id),
+            Expr::Tuple(ast::ExprTuple { elts, .. }) => elts
+                .iter()
+                .map(|expr| ConstantLikelihood::from_expression(expr, preview))
+                .min()
+                .unwrap_or(ConstantLikelihood::Definitely),
+            Expr::List(ast::ExprList { elts, .. }) if preview.is_enabled() => elts
+                .iter()
+                .map(|expr| ConstantLikelihood::from_expression(expr, preview))
+                .min()
+                .unwrap_or(ConstantLikelihood::Definitely),
+            Expr::Dict(ast::ExprDict { values: vs, .. }) if preview.is_enabled() => {
+                if vs.is_empty() {
+                    ConstantLikelihood::Definitely
+                } else {
+                    ConstantLikelihood::Probably
+                }
+            }
+            Expr::BinOp(ast::ExprBinOp { left, right, .. }) => cmp::min(
+                ConstantLikelihood::from_expression(left, preview),
+                ConstantLikelihood::from_expression(right, preview),
+            ),
+            Expr::UnaryOp(ast::ExprUnaryOp {
+                op: UnaryOp::UAdd | UnaryOp::USub | UnaryOp::Invert,
+                operand,
+                range: _,
+            }) => ConstantLikelihood::from_expression(operand, preview),
+            _ => ConstantLikelihood::Unlikely,
+        }
+    }
+
+    /// Determine the [`ConstantLikelihood`] of an identifier.
+    fn from_identifier(identifier: &str) -> Self {
+        if str::is_cased_uppercase(identifier) {
+            ConstantLikelihood::Probably
+        } else {
+            ConstantLikelihood::Unlikely
+        }
     }
 }
 
@@ -180,7 +230,9 @@ pub(crate) fn yoda_conditions(
         return;
     }
 
-    if !is_constant_like(left) || is_constant_like(right) {
+    if ConstantLikelihood::from_expression(left, checker.settings.preview)
+        <= ConstantLikelihood::from_expression(right, checker.settings.preview)
+    {
         return;
     }