Split Constant to individual literal nodes

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

@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Arguments, Constant, Expr, ExprContext, Operator};
+use ruff_python_ast::{self as ast, Arguments, Expr, ExprContext, Operator};
 use ruff_python_literal::cformat::{CFormatError, CFormatErrorType};
 
 use ruff_diagnostics::Diagnostic;
@@ -363,20 +363,18 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             ]) {
                 if let Expr::Attribute(ast::ExprAttribute { value, attr, .. }) = func.as_ref() {
                     let attr = attr.as_str();
-                    if let Expr::Constant(ast::ExprConstant {
-                        value: Constant::Str(val),
-                        ..
-                    }) = value.as_ref()
+                    if let Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) =
+                        value.as_ref()
                     {
                         if attr == "join" {
                             // "...".join(...) call
                             if checker.enabled(Rule::StaticJoinToFString) {
-                                flynt::rules::static_join_to_fstring(checker, expr, val);
+                                flynt::rules::static_join_to_fstring(checker, expr, string);
                             }
                         } else if attr == "format" {
                             // "...".format(...) call
                             let location = expr.range();
-                            match pyflakes::format::FormatSummary::try_from(val.as_ref()) {
+                            match pyflakes::format::FormatSummary::try_from(string.as_ref()) {
                                 Err(e) => {
                                     if checker.enabled(Rule::StringDotFormatInvalidFormat) {
                                         checker.diagnostics.push(Diagnostic::new(
@@ -421,7 +419,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
 
                             if checker.enabled(Rule::BadStringFormatCharacter) {
                                 pylint::rules::bad_string_format_character::call(
-                                    checker, val, location,
+                                    checker, string, location,
                                 );
                             }
                         }
@@ -987,11 +985,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             right,
             range: _,
         }) => {
-            if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(ast::StringConstant { value, .. }),
-                ..
-            }) = left.as_ref()
-            {
+            if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = left.as_ref() {
                 if checker.any_enabled(&[
                     Rule::PercentFormatInvalidFormat,
                     Rule::PercentFormatExpectedMapping,
@@ -1228,26 +1222,17 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 refurb::rules::single_item_membership_test(checker, expr, left, ops, comparators);
             }
         }
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Int(_) | Constant::Float(_) | Constant::Complex { .. },
-            range: _,
-        }) => {
+        Expr::NumberLiteral(_) => {
             if checker.source_type.is_stub() && checker.enabled(Rule::NumericLiteralTooLong) {
                 flake8_pyi::rules::numeric_literal_too_long(checker, expr);
             }
         }
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Bytes(_),
-            range: _,
-        }) => {
+        Expr::BytesLiteral(_) => {
             if checker.source_type.is_stub() && checker.enabled(Rule::StringOrBytesTooLong) {
                 flake8_pyi::rules::string_or_bytes_too_long(checker, expr);
             }
         }
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Str(value),
-            range: _,
-        }) => {
+        Expr::StringLiteral(ast::ExprStringLiteral { value, unicode, .. }) => {
             if checker.enabled(Rule::HardcodedBindAllInterfaces) {
                 if let Some(diagnostic) =
                     flake8_bandit::rules::hardcoded_bind_all_interfaces(value, expr.range())
@@ -1259,7 +1244,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_bandit::rules::hardcoded_tmp_directory(checker, expr, value);
             }
             if checker.enabled(Rule::UnicodeKindPrefix) {
-                pyupgrade::rules::unicode_kind_prefix(checker, expr, value.unicode);
+                pyupgrade::rules::unicode_kind_prefix(checker, expr, *unicode);
             }
             if checker.source_type.is_stub() {
                 if checker.enabled(Rule::StringOrBytesTooLong) {

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

@@ -31,7 +31,7 @@ use std::path::Path;
 use itertools::Itertools;
 use log::debug;
 use ruff_python_ast::{
-    self as ast, Arguments, Comprehension, Constant, ElifElseClause, ExceptHandler, Expr,
+    self as ast, Arguments, Comprehension, ElifElseClause, ExceptHandler, Expr,
     ExprContext, Keyword, MatchCase, Parameter, ParameterWithDefault, Parameters, Pattern, Stmt,
     Suite, UnaryOp,
 };
@@ -787,11 +787,7 @@ where
             && self.semantic.in_type_definition()
             && self.semantic.future_annotations()
         {
-            if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(value),
-                ..
-            }) = expr
-            {
+            if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = expr {
                 self.deferred.string_type_definitions.push((
                     expr.range(),
                     value,
@@ -1186,10 +1182,7 @@ where
                     }
                 }
             }
-            Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(value),
-                range: _,
-            }) => {
+            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
                 if self.semantic.in_type_definition()
                     && !self.semantic.in_literal()
                     && !self.semantic.in_f_string()

crates/ruff_linter/src/doc_lines.rs

@@ -3,7 +3,7 @@
 
 use std::iter::FusedIterator;
 
-use ruff_python_ast::{self as ast, Constant, Expr, Stmt, Suite};
+use ruff_python_ast::{self as ast, Stmt, Suite};
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::Tok;
 use ruff_text_size::{Ranged, TextSize};
@@ -70,11 +70,7 @@ struct StringLinesVisitor<'a> {
 impl StatementVisitor<'_> for StringLinesVisitor<'_> {
     fn visit_stmt(&mut self, stmt: &Stmt) {
         if let Stmt::Expr(ast::StmtExpr { value, range: _ }) = stmt {
-            if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(..),
-                ..
-            }) = value.as_ref()
-            {
+            if value.is_string_literal_expr() {
                 for line in UniversalNewlineIterator::with_offset(
                     self.locator.slice(value.as_ref()),
                     value.start(),

crates/ruff_linter/src/docstrings/extraction.rs

@@ -1,6 +1,6 @@
 //! Extract docstrings from an AST.
 
-use ruff_python_ast::{self as ast, Constant, Expr, Stmt};
+use ruff_python_ast::{self as ast, Expr, Stmt};
 use ruff_python_semantic::{Definition, DefinitionId, Definitions, Member, MemberKind};
 
 /// Extract a docstring from a function or class body.
@@ -11,13 +11,7 @@ pub(crate) fn docstring_from(suite: &[Stmt]) -> Option<&Expr> {
         return None;
     };
     // Only match strings.
-    if !matches!(
-        value.as_ref(),
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Str(_),
-            ..
-        })
-    ) {
+    if !value.is_string_literal_expr() {
         return None;
     }
     Some(value)

crates/ruff_linter/src/rules/airflow/rules/task_variable_name.rs

@@ -1,7 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast as ast;
-use ruff_python_ast::Constant;
 use ruff_python_ast::Expr;
 use ruff_text_size::Ranged;
 
@@ -79,12 +78,10 @@ pub(crate) fn variable_name_task_id(
     let keyword = arguments.find_keyword("task_id")?;
 
     // If the keyword argument is not a string, we can't do anything.
-    let task_id = match &keyword.value {
-        Expr::Constant(constant) => match &constant.value {
-            Constant::Str(ast::StringConstant { value, .. }) => value,
-            _ => return None,
-        },
-        _ => return None,
+    let Some(ast::ExprStringLiteral { value: task_id, .. }) =
+        keyword.value.as_string_literal_expr()
+    else {
+        return None;
     };
 
     // If the target name is the same as the task_id, no violation.

crates/ruff_linter/src/rules/flake8_2020/rules/compare.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, CmpOp, Constant, Expr};
+use ruff_python_ast::{self as ast, CmpOp, Expr};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -230,16 +230,16 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
         Expr::Subscript(ast::ExprSubscript { value, slice, .. })
             if is_sys(value, "version_info", checker.semantic()) =>
         {
-            if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Int(i),
+            if let Expr::NumberLiteral(ast::ExprNumberLiteral {
+                value: ast::Number::Int(i),
                 ..
             }) = slice.as_ref()
             {
                 if *i == 0 {
                     if let (
                         [CmpOp::Eq | CmpOp::NotEq],
-                        [Expr::Constant(ast::ExprConstant {
-                            value: Constant::Int(n),
+                        [Expr::NumberLiteral(ast::ExprNumberLiteral {
+                            value: ast::Number::Int(n),
                             ..
                         })],
                     ) = (ops, comparators)
@@ -253,8 +253,8 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
                 } else if *i == 1 {
                     if let (
                         [CmpOp::Lt | CmpOp::LtE | CmpOp::Gt | CmpOp::GtE],
-                        [Expr::Constant(ast::ExprConstant {
-                            value: Constant::Int(_),
+                        [Expr::NumberLiteral(ast::ExprNumberLiteral {
+                            value: ast::Number::Int(_),
                             ..
                         })],
                     ) = (ops, comparators)
@@ -274,8 +274,8 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
         {
             if let (
                 [CmpOp::Lt | CmpOp::LtE | CmpOp::Gt | CmpOp::GtE],
-                [Expr::Constant(ast::ExprConstant {
-                    value: Constant::Int(_),
+                [Expr::NumberLiteral(ast::ExprNumberLiteral {
+                    value: ast::Number::Int(_),
                     ..
                 })],
             ) = (ops, comparators)
@@ -294,13 +294,10 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
     if is_sys(left, "version", checker.semantic()) {
         if let (
             [CmpOp::Lt | CmpOp::LtE | CmpOp::Gt | CmpOp::GtE],
-            [Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(s),
-                ..
-            })],
+            [Expr::StringLiteral(ast::ExprStringLiteral { value, .. })],
         ) = (ops, comparators)
         {
-            if s.len() == 1 {
+            if value.len() == 1 {
                 if checker.enabled(Rule::SysVersionCmpStr10) {
                     checker
                         .diagnostics

crates/ruff_linter/src/rules/flake8_2020/rules/subscript.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Constant, Expr};
+use ruff_python_ast::{self as ast, Expr};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -177,8 +177,8 @@ pub(crate) fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
                 step: None,
                 range: _,
             }) => {
-                if let Expr::Constant(ast::ExprConstant {
-                    value: Constant::Int(i),
+                if let Expr::NumberLiteral(ast::ExprNumberLiteral {
+                    value: ast::Number::Int(i),
                     ..
                 }) = upper.as_ref()
                 {
@@ -194,8 +194,8 @@ pub(crate) fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
                 }
             }
 
-            Expr::Constant(ast::ExprConstant {
-                value: Constant::Int(i),
+            Expr::NumberLiteral(ast::ExprNumberLiteral {
+                value: ast::Number::Int(i),
                 ..
             }) => {
                 if *i == 2 && checker.enabled(Rule::SysVersion2) {

crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs

@@ -3,7 +3,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::ReturnStatementVisitor;
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::statement_visitor::StatementVisitor;
-use ruff_python_ast::{self as ast, Constant, Expr, ParameterWithDefault, Stmt};
+use ruff_python_ast::{self as ast, Expr, ParameterWithDefault, Stmt};
 use ruff_python_parser::typing::parse_type_annotation;
 use ruff_python_semantic::analyze::visibility;
 use ruff_python_semantic::Definition;
@@ -431,10 +431,7 @@ fn is_none_returning(body: &[Stmt]) -> bool {
     visitor.visit_body(body);
     for stmt in visitor.returns {
         if let Some(value) = stmt.value.as_deref() {
-            if !matches!(
-                value,
-                Expr::Constant(constant) if constant.value.is_none()
-            ) {
+            if !value.is_none_literal_expr() {
                 return false;
             }
         }
@@ -451,9 +448,10 @@ fn check_dynamically_typed<F>(
 ) where
     F: FnOnce() -> String,
 {
-    if let Expr::Constant(ast::ExprConstant {
+    if let Expr::StringLiteral(ast::ExprStringLiteral {
         range,
-        value: Constant::Str(string),
+        value: string,
+        ..
     }) = annotation
     {
         // Quoted annotations

crates/ruff_linter/src/rules/flake8_bandit/helpers.rs

@@ -1,6 +1,6 @@
 use once_cell::sync::Lazy;
 use regex::Regex;
-use ruff_python_ast::{self as ast, Constant, Expr};
+use ruff_python_ast::{self as ast, Expr};
 
 use ruff_python_semantic::SemanticModel;
 
@@ -10,10 +10,7 @@ static PASSWORD_CANDIDATE_REGEX: Lazy<Regex> = Lazy::new(|| {
 
 pub(super) fn string_literal(expr: &Expr) -> Option<&str> {
     match expr {
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Str(string),
-            ..
-        }) => Some(string),
+        Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => Some(value),
         _ => None,
     }
 }

crates/ruff_linter/src/rules/flake8_bandit/rules/bad_file_permissions.rs

@@ -3,7 +3,7 @@ use anyhow::Result;
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::call_path::CallPath;
-use ruff_python_ast::{self as ast, Constant, Expr, Operator};
+use ruff_python_ast::{self as ast, Expr, Operator};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
 
@@ -144,8 +144,8 @@ fn py_stat(call_path: &CallPath) -> Option<u16> {
 /// an integer value, but that value is out of range.
 fn parse_mask(expr: &Expr, semantic: &SemanticModel) -> Result<Option<u16>> {
     match expr {
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Int(int),
+        Expr::NumberLiteral(ast::ExprNumberLiteral {
+            value: ast::Number::Int(int),
             ..
         }) => match int.as_u16() {
             Some(value) => Ok(Some(value)),

crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_password_string.rs

@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Constant, Expr};
+use ruff_python_ast::{self as ast, Expr};
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -55,10 +55,7 @@ fn password_target(target: &Expr) -> Option<&str> {
         Expr::Name(ast::ExprName { id, .. }) => id.as_str(),
         // d["password"] = "s3cr3t"
         Expr::Subscript(ast::ExprSubscript { slice, .. }) => match slice.as_ref() {
-            Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(string),
-                ..
-            }) => string,
+            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value,
             _ => return None,
         },
         // obj.password = "s3cr3t"