Less confidently mark f-strings as empty when inferring truthiness (#20152)

When computing the boolean value of an f-string, we over-eagerly
interpreted some f-string interpolations as empty. In this PR we now
mark the truthiness of f-strings involving format specs, debug text, and
bytes literals as "unknown".

This will probably result in some false negatives, which may be further
refined (for example - there are probably many cases where
`is_not_empty_f_string` should be modified to return `true`), but for
now at least we should have fewer false positives.

Affected rules (may not be an exhaustive list):

- [unnecessary-empty-iterable-within-deque-call
(RUF037)](https://docs.astral.sh/ruff/rules/unnecessary-empty-iterable-within-deque-call/#unnecessary-empty-iterable-within-deque-call-ruf037)
- [falsy-dict-get-fallback
(RUF056)](https://docs.astral.sh/ruff/rules/falsy-dict-get-fallback/#falsy-dict-get-fallback-ruf056)
- [pytest-assert-always-false
(PT015)](https://docs.astral.sh/ruff/rules/pytest-assert-always-false/#pytest-assert-always-false-pt015)
- [expr-or-not-expr
(SIM221)](https://docs.astral.sh/ruff/rules/expr-or-not-expr/#expr-or-not-expr-sim221)
- [expr-or-true
(SIM222)](https://docs.astral.sh/ruff/rules/expr-or-true/#expr-or-true-sim222)
- [expr-and-false
(SIM223)](https://docs.astral.sh/ruff/rules/expr-and-false/#expr-and-false-sim223)

Closes #19935

crates/ruff_python_ast/src/helpers.rs

@@ -1410,31 +1410,38 @@ pub fn is_empty_f_string(expr: &ast::ExprFString) -> bool {
     fn inner(expr: &Expr) -> bool {
         match expr {
             Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value.is_empty(),
-            Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => value.is_empty(),
+            // Confusingly, `bool(f"{b""}") == True` even though
+            // `bool(b"") == False`. This is because `f"{b""}"`
+            // evaluates as the string `'b""'` of length 3.
+            Expr::BytesLiteral(_) => false,
             Expr::FString(ast::ExprFString { value, .. }) => {
-                value
-                    .elements()
-                    .all(|f_string_element| match f_string_element {
-                        InterpolatedStringElement::Literal(
-                            ast::InterpolatedStringLiteralElement { value, .. },
-                        ) => value.is_empty(),
-                        InterpolatedStringElement::Interpolation(ast::InterpolatedElement {
-                            expression,
-                            ..
-                        }) => inner(expression),
-                    })
+                is_empty_interpolated_elements(value.elements())
             }
             _ => false,
         }
     }
 
+    fn is_empty_interpolated_elements<'a>(
+        mut elements: impl Iterator<Item = &'a InterpolatedStringElement>,
+    ) -> bool {
+        elements.all(|element| match element {
+            InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
+                value,
+                ..
+            }) => value.is_empty(),
+            InterpolatedStringElement::Interpolation(f_string) => {
+                f_string.debug_text.is_none()
+                    && f_string.conversion.is_none()
+                    && f_string.format_spec.is_none()
+                    && inner(&f_string.expression)
+            }
+        })
+    }
+
     expr.value.iter().all(|part| match part {
         ast::FStringPart::Literal(string_literal) => string_literal.is_empty(),
         ast::FStringPart::FString(f_string) => {
-            f_string.elements.iter().all(|element| match element {
-                InterpolatedStringElement::Literal(string_literal) => string_literal.is_empty(),
-                InterpolatedStringElement::Interpolation(f_string) => inner(&f_string.expression),
-            })
+            is_empty_interpolated_elements(f_string.elements.iter())
         }
     })
 }