Split Constant to individual literal nodes (#8064)

## Summary

This PR splits the `Constant` enum as individual literal nodes. It
introduces the following new nodes for each variant:
* `ExprStringLiteral`
* `ExprBytesLiteral`
* `ExprNumberLiteral`
* `ExprBooleanLiteral`
* `ExprNoneLiteral`
* `ExprEllipsisLiteral`

The main motivation behind this refactor is to introduce the new AST
node for implicit string concatenation in the coming PR. The elements of
that node will be either a string literal, bytes literal or a f-string
which can be implemented using an enum. This means that a string or
bytes literal cannot be represented by `Constant::Str` /
`Constant::Bytes` which creates an inconsistency.

This PR avoids that inconsistency by splitting the constant nodes into
it's own literal nodes, literal being the more appropriate naming
convention from a static analysis tool perspective.

This also makes working with literals in the linter and formatter much
more ergonomic like, for example, if one would want to check if this is
a string literal, it can be done easily using
`Expr::is_string_literal_expr` or matching against `Expr::StringLiteral`
as oppose to matching against the `ExprConstant` and enum `Constant`. A
few AST helper methods can be simplified as well which will be done in a
follow-up PR.

This introduces a new `Expr::is_literal_expr` method which is the same
as `Expr::is_constant_expr`. There are also intermediary changes related
to implicit string concatenation which are quiet less. This is done so
as to avoid having a huge PR which this already is.

## Test Plan

1. Verify and update all of the existing snapshots (parser, visitor)
2. Verify that the ecosystem check output remains **unchanged** for both
the linter and formatter

### Formatter ecosystem check

#### `main`

| project | similarity index | total files | changed files |

|----------------|------------------:|------------------:|------------------:|
| cpython | 0.75803 | 1799 | 1647 |
| django | 0.99983 | 2772 | 34 |
| home-assistant | 0.99953 | 10596 | 186 |
| poetry | 0.99891 | 317 | 17 |
| transformers | 0.99966 | 2657 | 330 |
| twine | 1.00000 | 33 | 0 |
| typeshed | 0.99978 | 3669 | 20 |
| warehouse | 0.99977 | 654 | 13 |
| zulip | 0.99970 | 1459 | 22 |

#### `dhruv/constant-to-literal`

| project | similarity index | total files | changed files |

|----------------|------------------:|------------------:|------------------:|
| cpython | 0.75803 | 1799 | 1647 |
| django | 0.99983 | 2772 | 34 |
| home-assistant | 0.99953 | 10596 | 186 |
| poetry | 0.99891 | 317 | 17 |
| transformers | 0.99966 | 2657 | 330 |
| twine | 1.00000 | 33 | 0 |
| typeshed | 0.99978 | 3669 | 20 |
| warehouse | 0.99977 | 654 | 13 |
| zulip | 0.99970 | 1459 | 22 |

crates/ruff_python_ast/src/comparable.rs

@@ -344,45 +344,21 @@ impl From<&ast::Singleton> for ComparableSingleton {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
-pub enum ComparableConstant<'a> {
-    None,
-    Bool(&'a bool),
-    Str { value: &'a str, unicode: bool },
-    Bytes(&'a [u8]),
+pub enum ComparableNumber<'a> {
     Int(&'a ast::Int),
     Float(u64),
     Complex { real: u64, imag: u64 },
-    Ellipsis,
 }
 
-impl<'a> From<&'a ast::Constant> for ComparableConstant<'a> {
-    fn from(constant: &'a ast::Constant) -> Self {
-        match constant {
-            ast::Constant::None => Self::None,
-            ast::Constant::Bool(value) => Self::Bool(value),
-            ast::Constant::Str(ast::StringConstant {
-                value,
-                // Compare strings based on resolved value, not representation (i.e., ignore whether
-                // the string was implicitly concatenated).
-                implicit_concatenated: _,
-                unicode,
-            }) => Self::Str {
-                value,
-                unicode: *unicode,
-            },
-            ast::Constant::Bytes(ast::BytesConstant {
-                value,
-                // Compare bytes based on resolved value, not representation (i.e., ignore whether
-                // the bytes were implicitly concatenated).
-                implicit_concatenated: _,
-            }) => Self::Bytes(value),
-            ast::Constant::Int(value) => Self::Int(value),
-            ast::Constant::Float(value) => Self::Float(value.to_bits()),
-            ast::Constant::Complex { real, imag } => Self::Complex {
+impl<'a> From<&'a ast::Number> for ComparableNumber<'a> {
+    fn from(number: &'a ast::Number) -> Self {
+        match number {
+            ast::Number::Int(value) => Self::Int(value),
+            ast::Number::Float(value) => Self::Float(value.to_bits()),
+            ast::Number::Complex { real, imag } => Self::Complex {
                 real: real.to_bits(),
                 imag: imag.to_bits(),
             },
-            ast::Constant::Ellipsis => Self::Ellipsis,
         }
     }
 }
@@ -669,8 +645,24 @@ pub struct ExprFString<'a> {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
-pub struct ExprConstant<'a> {
-    value: ComparableConstant<'a>,
+pub struct ExprStringLiteral<'a> {
+    value: &'a str,
+    unicode: &'a bool,
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ExprBytesLiteral<'a> {
+    value: &'a [u8],
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ExprNumberLiteral<'a> {
+    value: ComparableNumber<'a>,
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct ExprBoolLiteral<'a> {
+    value: &'a bool,
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -739,7 +731,12 @@ pub enum ComparableExpr<'a> {
     Call(ExprCall<'a>),
     FormattedValue(ExprFormattedValue<'a>),
     FString(ExprFString<'a>),
-    Constant(ExprConstant<'a>),
+    StringLiteral(ExprStringLiteral<'a>),
+    BytesLiteral(ExprBytesLiteral<'a>),
+    NumberLiteral(ExprNumberLiteral<'a>),
+    BoolLiteral(ExprBoolLiteral<'a>),
+    NoneLiteral,
+    EllispsisLiteral,
     Attribute(ExprAttribute<'a>),
     Subscript(ExprSubscript<'a>),
     Starred(ExprStarred<'a>),
@@ -913,11 +910,31 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
             }) => Self::FString(ExprFString {
                 values: values.iter().map(Into::into).collect(),
             }),
-            ast::Expr::Constant(ast::ExprConstant { value, range: _ }) => {
-                Self::Constant(ExprConstant {
+            ast::Expr::StringLiteral(ast::ExprStringLiteral {
+                value,
+                // Compare strings based on resolved value, not representation (i.e., ignore whether
+                // the string was implicitly concatenated).
+                implicit_concatenated: _,
+                unicode,
+                range: _,
+            }) => Self::StringLiteral(ExprStringLiteral { value, unicode }),
+            ast::Expr::BytesLiteral(ast::ExprBytesLiteral {
+                value,
+                // Compare bytes based on resolved value, not representation (i.e., ignore whether
+                // the bytes was implicitly concatenated).
+                implicit_concatenated: _,
+                range: _,
+            }) => Self::BytesLiteral(ExprBytesLiteral { value }),
+            ast::Expr::NumberLiteral(ast::ExprNumberLiteral { value, range: _ }) => {
+                Self::NumberLiteral(ExprNumberLiteral {
                     value: value.into(),
                 })
             }
+            ast::Expr::BooleanLiteral(ast::ExprBooleanLiteral { value, range: _ }) => {
+                Self::BoolLiteral(ExprBoolLiteral { value })
+            }
+            ast::Expr::NoneLiteral(_) => Self::NoneLiteral,
+            ast::Expr::EllipsisLiteral(_) => Self::EllispsisLiteral,
             ast::Expr::Attribute(ast::ExprAttribute {
                 value,
                 attr,