Update AST checker with new string_like analyzer

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -4,7 +4,6 @@ use ruff_python_literal::cformat::{CFormatError, CFormatErrorType};
 use ruff_diagnostics::Diagnostic;
 
 use ruff_python_ast::types::Node;
-use ruff_python_ast::AstNode;
 use ruff_python_semantic::analyze::typing;
 use ruff_python_semantic::ScopeKind;
 use ruff_text_size::Ranged;
@@ -1007,30 +1006,6 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     pyupgrade::rules::unicode_kind_prefix(checker, string_literal);
                 }
             }
-            for literal in value.elements().filter_map(|element| element.as_literal()) {
-                if checker.enabled(Rule::HardcodedBindAllInterfaces) {
-                    flake8_bandit::rules::hardcoded_bind_all_interfaces(
-                        checker,
-                        &literal.value,
-                        literal.range,
-                    );
-                }
-                if checker.enabled(Rule::HardcodedTempFile) {
-                    flake8_bandit::rules::hardcoded_tmp_directory(
-                        checker,
-                        &literal.value,
-                        literal.range,
-                    );
-                }
-                if checker.source_type.is_stub() {
-                    if checker.enabled(Rule::StringOrBytesTooLong) {
-                        flake8_pyi::rules::string_or_bytes_too_long(
-                            checker,
-                            literal.as_any_node_ref(),
-                        );
-                    }
-                }
-            }
         }
         Expr::BinOp(ast::ExprBinOp {
             left,
@@ -1295,38 +1270,12 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 refurb::rules::math_constant(checker, number_literal);
             }
         }
-        Expr::BytesLiteral(bytes_literal) => {
-            if checker.source_type.is_stub() && checker.enabled(Rule::StringOrBytesTooLong) {
-                flake8_pyi::rules::string_or_bytes_too_long(
-                    checker,
-                    bytes_literal.as_any_node_ref(),
-                );
-            }
-        }
-        Expr::StringLiteral(string_literal @ ast::ExprStringLiteral { value, range }) => {
-            if checker.enabled(Rule::HardcodedBindAllInterfaces) {
-                flake8_bandit::rules::hardcoded_bind_all_interfaces(
-                    checker,
-                    value.to_str(),
-                    *range,
-                );
-            }
-            if checker.enabled(Rule::HardcodedTempFile) {
-                flake8_bandit::rules::hardcoded_tmp_directory(checker, value.to_str(), *range);
-            }
+        Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
             if checker.enabled(Rule::UnicodeKindPrefix) {
                 for string_part in value.parts() {
                     pyupgrade::rules::unicode_kind_prefix(checker, string_part);
                 }
             }
-            if checker.source_type.is_stub() {
-                if checker.enabled(Rule::StringOrBytesTooLong) {
-                    flake8_pyi::rules::string_or_bytes_too_long(
-                        checker,
-                        string_literal.as_any_node_ref(),
-                    );
-                }
-            }
         }
         Expr::IfExp(
             if_exp @ ast::ExprIfExp {

crates/ruff_linter/src/checkers/ast/analyze/mod.rs

@@ -10,6 +10,7 @@ pub(super) use module::module;
 pub(super) use parameter::parameter;
 pub(super) use parameters::parameters;
 pub(super) use statement::statement;
+pub(super) use string_like::string_like;
 pub(super) use suite::suite;
 pub(super) use unresolved_references::unresolved_references;
 
@@ -25,5 +26,6 @@ mod module;
 mod parameter;
 mod parameters;
 mod statement;
+mod string_like;
 mod suite;
 mod unresolved_references;

crates/ruff_linter/src/checkers/ast/analyze/string_like.rs

@@ -0,0 +1,20 @@
+use ruff_python_ast::StringLike;
+
+use crate::checkers::ast::Checker;
+use crate::codes::Rule;
+use crate::rules::{flake8_bandit, flake8_pyi};
+
+/// Run lint rules over a [`StringLike`] syntax nodes.
+pub(crate) fn string_like(string_like: StringLike, checker: &mut Checker) {
+    if checker.enabled(Rule::HardcodedBindAllInterfaces) {
+        flake8_bandit::rules::hardcoded_bind_all_interfaces(checker, string_like);
+    }
+    if checker.enabled(Rule::HardcodedTempFile) {
+        flake8_bandit::rules::hardcoded_tmp_directory(checker, string_like);
+    }
+    if checker.source_type.is_stub() {
+        if checker.enabled(Rule::StringOrBytesTooLong) {
+            flake8_pyi::rules::string_or_bytes_too_long(checker, string_like);
+        }
+    }
+}

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

@@ -44,7 +44,7 @@ use ruff_python_ast::helpers::{
 };
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::str::trailing_quote;
-use ruff_python_ast::visitor::{walk_except_handler, walk_pattern, Visitor};
+use ruff_python_ast::visitor::{walk_except_handler, walk_f_string_element, walk_pattern, Visitor};
 use ruff_python_ast::{helpers, str, visitor, PySourceType};
 use ruff_python_codegen::{Generator, Quote, Stylist};
 use ruff_python_index::Indexer;
@@ -1267,6 +1267,13 @@ where
 
         // Step 4: Analysis
         analyze::expression(expr, self);
+        match expr {
+            Expr::StringLiteral(string_literal) => {
+                analyze::string_like(string_literal.into(), self);
+            }
+            Expr::BytesLiteral(bytes_literal) => analyze::string_like(bytes_literal.into(), self),
+            _ => {}
+        }
 
         self.semantic.flags = flags_snapshot;
         self.semantic.pop_node();
@@ -1431,6 +1438,16 @@ where
                 .push((bound, self.semantic.snapshot()));
         }
     }
+
+    fn visit_f_string_element(&mut self, f_string_element: &'b ast::FStringElement) {
+        // Step 2: Traversal
+        walk_f_string_element(self, f_string_element);
+
+        // Step 4: Analysis
+        if let Some(literal) = f_string_element.as_literal() {
+            analyze::string_like(literal.into(), self);
+        }
+    }
 }
 
 impl<'a> Checker<'a> {