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_semantic/src/analyze/type_inference.rs

@@ -3,7 +3,7 @@
 use rustc_hash::FxHashSet;
 
 use ruff_python_ast as ast;
-use ruff_python_ast::{Constant, Expr, Operator, UnaryOp};
+use ruff_python_ast::{Expr, Operator, UnaryOp};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ResolvedPythonType {
@@ -59,22 +59,24 @@ impl From<&Expr> for ResolvedPythonType {
             Expr::Tuple(_) => ResolvedPythonType::Atom(PythonType::Tuple),
             Expr::GeneratorExp(_) => ResolvedPythonType::Atom(PythonType::Generator),
             Expr::FString(_) => ResolvedPythonType::Atom(PythonType::String),
-            Expr::Constant(ast::ExprConstant { value, .. }) => match value {
-                Constant::Str(_) => ResolvedPythonType::Atom(PythonType::String),
-                Constant::Int(_) => {
+            Expr::StringLiteral(_) => ResolvedPythonType::Atom(PythonType::String),
+            Expr::BytesLiteral(_) => ResolvedPythonType::Atom(PythonType::Bytes),
+            Expr::NumberLiteral(ast::ExprNumberLiteral { value, .. }) => match value {
+                ast::Number::Int(_) => {
                     ResolvedPythonType::Atom(PythonType::Number(NumberLike::Integer))
                 }
-                Constant::Float(_) => {
+                ast::Number::Float(_) => {
                     ResolvedPythonType::Atom(PythonType::Number(NumberLike::Float))
                 }
-                Constant::Bool(_) => ResolvedPythonType::Atom(PythonType::Number(NumberLike::Bool)),
-                Constant::Complex { .. } => {
+                ast::Number::Complex { .. } => {
                     ResolvedPythonType::Atom(PythonType::Number(NumberLike::Complex))
                 }
-                Constant::None => ResolvedPythonType::Atom(PythonType::None),
-                Constant::Ellipsis => ResolvedPythonType::Atom(PythonType::Ellipsis),
-                Constant::Bytes(_) => ResolvedPythonType::Atom(PythonType::Bytes),
             },
+            Expr::BooleanLiteral(_) => {
+                ResolvedPythonType::Atom(PythonType::Number(NumberLike::Bool))
+            }
+            Expr::NoneLiteral(_) => ResolvedPythonType::Atom(PythonType::None),
+            Expr::EllipsisLiteral(_) => ResolvedPythonType::Atom(PythonType::Ellipsis),
             // Simple container expressions.
             Expr::NamedExpr(ast::ExprNamedExpr { value, .. }) => {
                 ResolvedPythonType::from(value.as_ref())

crates/ruff_python_semantic/src/analyze/typing.rs

@@ -2,9 +2,7 @@
 
 use ruff_python_ast::call_path::{from_qualified_name, from_unqualified_name, CallPath};
 use ruff_python_ast::helpers::{any_over_expr, is_const_false, map_subscript};
-use ruff_python_ast::{
-    self as ast, Constant, Expr, Int, Operator, ParameterWithDefault, Parameters, Stmt,
-};
+use ruff_python_ast::{self as ast, Expr, Int, Operator, ParameterWithDefault, Parameters, Stmt};
 use ruff_python_stdlib::typing::{
     as_pep_585_generic, has_pep_585_generic, is_immutable_generic_type,
     is_immutable_non_generic_type, is_immutable_return_type, is_literal_member,
@@ -144,10 +142,7 @@ pub fn to_pep604_operator(
     /// Returns `true` if any argument in the slice is a quoted annotation.
     fn quoted_annotation(slice: &Expr) -> bool {
         match slice {
-            Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(_),
-                ..
-            }) => true,
+            Expr::StringLiteral(_) => true,
             Expr::Tuple(ast::ExprTuple { elts, .. }) => elts.iter().any(quoted_annotation),
             _ => false,
         }
@@ -257,10 +252,7 @@ pub fn is_immutable_annotation(
             is_immutable_annotation(left, semantic, extend_immutable_calls)
                 && is_immutable_annotation(right, semantic, extend_immutable_calls)
         }
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::None,
-            ..
-        }) => true,
+        Expr::NoneLiteral(_) => true,
         _ => false,
     }
 }
@@ -314,8 +306,8 @@ pub fn is_type_checking_block(stmt: &ast::StmtIf, semantic: &SemanticModel) -> b
     // Ex) `if 0:`
     if matches!(
         test.as_ref(),
-        Expr::Constant(ast::ExprConstant {
-            value: Constant::Int(Int::ZERO),
+        Expr::NumberLiteral(ast::ExprNumberLiteral {
+            value: ast::Number::Int(Int::ZERO),
             ..
         })
     ) {